file_content
stringlengths 65
76k
| goals
int64 1
283
|
|---|---|
/* run.config
OPT: -wp-no-print -wp-rte
*/
/* run.config_qualif
OPT: -then -wp-rte -wp
*/
/* ************/
/* Solution de TP donné par Julien à L'IFIPS */
/* ************/
/*
Questions:
1. Informellement, que calcule cette fonction?
2. Donner une spécification en ACSL de cette fonction.
3. Prouver cette fonction avec WP et Alt-Ergo. La preuve doit inclure la
terminaison et l'absence d'erreur à l'exécution.
*/
/*@ requires len > 0;
@ requires \valid(a+(0..len-1));
@ ensures 0 <= \result < len;
@ ensures \forall integer i; 0 <= i < len ==> a[i] <= a[\result];
@ assigns \nothing; */
int exo1(int *a, int len) {
int i = 0, j = len - 1;
/*@ loop invariant 0 <= i <= j < len;
@ loop invariant
@ \forall integer k;
@ (0 <= k < i || j < k < len)
@ ==> (a[k] <= a[i] || a[k] <= a[j]);
@ loop assigns i, j;
@ loop variant j - i; */
while (i < j)
if (a[i] <= a[j]) i++;
else j--;
return i;
}
| 17 |
typedef enum { Max, Min } kind;
int extremum (kind k, int x, int y) {
return ((k == Max ? x > y : x < y) ? x: y);
}
/*@ requires k == Max || k == Min;
assigns \nothing;
ensures \result == x || \result == y;
behavior is_max:
assumes k == Max;
ensures \result >= x && \result >= y;
behavior is_min:
assumes k == Min;
ensures \result <= x && \result <= y;
complete behaviors is_max, is_min;
disjoint behaviors is_max, is_min;
complete behaviors;
disjoint behaviors;
*/
int extremum (kind k, int x, int y);
| 11 |
#include <limits.h>
#include <string.h>
/*@ logic integer cypher(int x0) = (((x0==26)) ? (0) : ((x0+1)));*/
/*@
requires ((0<=x0) &&
(x0<=26));
assigns \nothing;
ensures ((0<=\result) &&
(\result<=26));
ensures \result == cypher(x0);
*/
int cypher(int x0) {
int x2 = x0 == 26;
int x4;
if (x2) {
x4 = 0;
} else {
int x3 = x0 + 1;
x4 = x3;
}
return x4;
}
/*@ logic integer decypher(int x11) = (((x11==0)) ? (26) : ((x11-1)));*/
/*@
requires ((0<=x11) &&
(x11<=26));
assigns \nothing;
ensures ((0<=\result) &&
(\result<=26));
ensures \result == decypher(x11);
*/
int decypher(int x11) {
int x13 = x11 == 0;
int x15;
if (x13) {
x15 = 26;
} else {
int x14 = x11 - 1;
x15 = x14;
}
return x15;
}
/*@
requires ((((((x25>0) &&
\valid(x22+(0..x25-1))) &&
\valid(x23+(0..x25-1))) &&
\valid(x24+(0..x25-1))) &&
(\forall int x88; (((0<=x88) &&
(x88<x25)) ==> (\forall int x92; (((0<=x92) &&
(x92<x25)) ==> (\forall int x96; (((0<=x96) &&
(x96<x25)) ==> ((\separated(x22+x88,x23+x92) &&
\separated(x22+x88,x24+x96)) &&
\separated(x23+x92,x24+x96))))))))) &&
(\forall int x114; (((0<=x114) &&
(x114<x25)) ==> ((0<=x22[x114]) &&
(x22[x114]<=26)))));
ensures ((((\forall int x126; (((0<=x126) &&
(x126<x25)) ==> (x23[x126]==cypher(x22[x126])))) &&
(\forall int x137; (((0<=x137) &&
(x137<x25)) ==> ((0<=x23[x137]) &&
(x23[x137]<=26))))) &&
(\forall int x149; (((0<=x149) &&
(x149<x25)) ==> (\old(x22[x149])==x22[x149])))) &&
(\forall int x159; (((0<=x159) &&
(x159<x25)) ==> (\old(x24[x159])==x24[x159]))));
assigns x23[(0..x25-1)];
*/
void encode(int * x22, int * x23, int * x24, int x25) {
/*@
loop invariant 0<=x28<=x25;
loop invariant (\forall int x29; (((0<=x29) &&
(x29<x25)) ==> ((0<=x22[x29]) &&
(x22[x29]<=26))));
loop invariant (\forall int x39; (((0<=x39) &&
(x39<x25)) ==> (\at(x22[x39],Pre)==x22[x39])));
loop invariant (\forall int x48; (((0<=x48) &&
(x48<x25)) ==> (\at(x24[x48],Pre)==x24[x48])));
loop invariant (\forall int x57; (((0<=x57) &&
(x57<x28)) ==> (x23[x57]==cypher(x22[x57]))));
loop assigns x28, x23[(0..x25-1)];
loop variant x25-x28;
*/
for(int x28=0; x28 < x25; x28++) {
int x71 = x22[x28];
int x72 = cypher(x71);
x23[x28] = x72;
/*@assert (x23[x28]==x72);*/
}
}
/*@
requires ((((((x172>0) &&
\valid(x169+(0..x172-1))) &&
\valid(x170+(0..x172-1))) &&
\valid(x171+(0..x172-1))) &&
(\forall int x235; (((0<=x235) &&
(x235<x172)) ==> (\forall int x239; (((0<=x239) &&
(x239<x172)) ==> (\forall int x243; (((0<=x243) &&
(x243<x172)) ==> ((\separated(x169+x235,x170+x239) &&
\separated(x169+x235,x171+x243)) &&
\separated(x170+x239,x171+x243))))))))) &&
(\forall int x261; (((0<=x261) &&
(x261<x172)) ==> ((0<=x169[x261]) &&
(x169[x261]<=26)))));
ensures ((((\forall int x273; (((0<=x273) &&
(x273<x172)) ==> (x170[x273]==decypher(x169[x273])))) &&
(\forall int x284; (((0<=x284) &&
(x284<x172)) ==> ((0<=x170[x284]) &&
(x170[x284]<=26))))) &&
(\forall int x296; (((0<=x296) &&
(x296<x172)) ==> (\old(x169[x296])==x169[x296])))) &&
(\forall int x306; (((0<=x306) &&
(x306<x172)) ==> (\old(x171[x306])==x171[x306]))));
assigns x170[(0..x172-1)];
*/
void decode(int * x169, int * x170, int * x171, int x172) {
/*@
loop invariant 0<=x175<=x172;
loop invariant (\forall int x176; (((0<=x176) &&
(x176<x172)) ==> ((0<=x169[x176]) &&
(x169[x176]<=26))));
loop invariant (\forall int x186; (((0<=x186) &&
(x186<x172)) ==> (\at(x169[x186],Pre)==x169[x186])));
loop invariant (\forall int x195; (((0<=x195) &&
(x195<x172)) ==> (\at(x171[x195],Pre)==x171[x195])));
loop invariant (\forall int x204; (((0<=x204) &&
(x204<x175)) ==> (x170[x204]==decypher(x169[x204]))));
loop assigns x175, x170[(0..x172-1)];
loop variant x172-x175;
*/
for(int x175=0; x175 < x172; x175++) {
int x218 = x169[x175];
int x219 = decypher(x218);
x170[x175] = x219;
/*@assert (x170[x175]==x219);*/
}
}
/*@
requires ((((((x319>0) &&
\valid(x316+(0..x319-1))) &&
\valid(x317+(0..x319-1))) &&
\valid(x318+(0..x319-1))) &&
(\forall int x332; (((0<=x332) &&
(x332<x319)) ==> (\forall int x336; (((0<=x336) &&
(x336<x319)) ==> (\forall int x340; (((0<=x340) &&
(x340<x319)) ==> ((\separated(x316+x332,x317+x336) &&
\separated(x316+x332,x318+x340)) &&
\separated(x317+x336,x318+x340))))))))) &&
(\forall int x359; (((0<=x359) &&
(x359<x319)) ==> ((0<=x316[x359]) &&
(x316[x359]<=26)))));
ensures ((\forall int x371; (((0<=x371) &&
(x371<x319)) ==> (x318[x371]==x316[x371]))) &&
(\forall int x381; (((0<=x381) &&
(x381<x319)) ==> (\old(x316[x381])==x316[x381]))));
assigns x317[(0..x319-1)], x318[(0..x319-1)];
*/
void autoencode(int * x316, int * x317, int * x318, int x319) {
encode(x316,x317,x318,x319);
decode(x317,x318,x316,x319);
}
| 77 |
#include "string.h"
/*@
requires valid_string(s);
assigns s[0..(strlen(s) - 2)];
ensures strlen(s) ≡ \old(strlen(s));
ensures s ≡ \old(s);
*/
void a(char* s);
/*@
requires valid_string(s);
assigns s[0..strlen(\old(s))];
ensures strlen(s) ≡ strlen(s);
ensures s ≡ \old(s);
*/
void b(char *s) {
int x = 0;
a(s);
//@ assert x ≡ 0;
}
/*@
requires valid_string(s);
assigns s[0..n];
*/
void an(char* s, int n);
/*@
requires valid_string(s);
assigns s[0..n];
*/
void bn(char *s, int n) {
an(s, n);
}
| 13 |
/*@ assigns \nothing;
ensures \result == \max(\max(a, b), \max(b, c));
*/
int max3(int a, int b, int c)
{
return a > b ? (a > c ? a : c) : (b > c ? b : c);
}
| 9 |
#include <stdio.h>
#include <string.h>
#include <limits.h>
/*@ requires N >= 0 && \valid_read(a + (0..N-1));
assigns \nothing;
behavior empty:
assumes N == 0;
ensures \result == 0;
behavior not_empty:
assumes 0 < N;
ensures 0 <= \result < N;
ensures
\forall integer i;
0 <= i < N ==> a[i] <= a[\result];
ensures
\forall integer i;
0 <= i < \result ==> a[i] < a[\result];
complete behaviors;
disjoint behaviors;
*/
int max(int* a, int N)
{
if (N == 0)
{
return 0;
}
int i;
int max = 0;
/*@
loop invariant 0 <= i <= N;
loop invariant 0 <= max < N;
loop invariant
\forall integer k;
0 <= k < i ==> a[k] <= a[max];
loop invariant
\forall integer k;
0 <= k < max ==> a[k] < a[max];
loop assigns max, i;
loop variant N-i;
*/
for (i = 0; i < N; i++)
{
if (a[max] < a[i])
{
max = i;
}
}
return max;
}
int main()
{
int N = 6;
//int* a;
//a = (int*) malloc(N*sizeof(int));
int a[N];
memcpy(a, (int[]) {23, 50, 61, 124, 562, 1000}, sizeof a);
//a = {23, 50, 61, 124, 562, 1000};
//*(a + 0) = 23;
//*(a + 1) = 50;
//*(a + 2) = 61;
//a[3] = 124;
//a[4] = 563;
//a[5] = 1000;
// max from odd numbers
int max_index = max(a, N);
printf("max_from_arr = %i\n", a[max_index]);
return 0;
}
| 17 |
// Command: frama-c -wp -wp-rte program.c
// Frama-c version : Silicon (last release)
// The algorithm is proved to sort, but does not ensure the preservation of the elements of the initial array
// swap and same_elements are from http://nikolai.kosmatov.free.fr/publications/tutorial_2013_06_18_tap2013_slides.pdf
/*@ predicate swap{L1, L2}(int *a, int *b, integer begin, integer i, integer j, integer end) =
begin <= i < j < end &&
\at(a[i], L1) == \at(b[j], L2) &&
\at(a[j], L1) == \at(b[i], L2) &&
\forall integer k; begin <= k < end && k != i && k != j ==>
\at(a[k], L1) == \at(b[k], L2);
predicate same_array{L1,L2}(int *a, int *b, integer begin, integer end) =
\forall integer k; begin <= k < end ==> \at(a[k],L1) == \at(b[k],L2);
inductive same_elements{L1, L2}(int *a, int *b, integer begin, integer end) {
case refl{L1, L2}:
\forall int *a, int *b, integer begin, end;
same_array{L1,L2}(a, b, begin, end) ==>
same_elements{L1, L2}(a, b, begin, end);
case swap{L1, L2}: \forall int *a, int *b, integer begin, i, j, end;
swap{L1, L2}(a, b, begin, i, j, end) ==>
same_elements{L1, L2}(a, b, begin, end);
case trans{L1, L2, L3}: \forall int* a, int *b, int *c, integer begin, end;
same_elements{L1, L2}(a, b, begin, end) ==>
same_elements{L2, L3}(b, c, begin, end) ==>
same_elements{L1, L3}(a, c, begin, end);
}
*/
/*@ ghost int *t;*/
/*@ requires \valid(t+(0..n-1));
requires \separated(t+(0..n-1),a+(0..n-1));
requires same_array{Pre, Pre}(a, t, 0, n);
requires n >= 0;
requires \valid(a+(0..n-1));
assigns a[0..n-1],t[0..n-1];
ensures sorted: \forall integer i, j; 0 <= i <= j < n ==> a[i] <= a[j]; // the final array is sorted
ensures \forall integer k; 0 <= k < n ==> a[k] == t[k];
ensures same_elements{Pre, Post}(t, t, 0, n);
ensures same_elements{Pre, Post}(a, a, 0, n); // the array contains the same elements at the end as in the beginning
*/
void pair_sort(int a[], int n) {
int i = 0; // i is running index (inc by 2 every iteration)
/*@ loop invariant \forall integer k, l; 0 <= k <= l < i ==> a[k] <= a[l]; // the sub-array a[0..i-1] is sorted
loop invariant same_elements{Pre, Here}(t, t, 0, n);
loop invariant \forall integer k; 0 <= k < n ==> a[k] == t[k];
loop invariant 0 <= i <= n;
loop assigns i, a[0..n-1],t[0..n-1];
loop variant n - 1 - i;
*/
while (i < n-1) {
int x = a[i];
// let x and y hold the next to elements in A
int y = a[i+1];
if (x < y) {
// ensure that x is not smaller than y
int tmp = x;
x = y;
y = tmp;
}
int j = i - 1;
// j is the index used to find the insertion point
/*@ loop invariant \forall integer k, l; 0 <= k <= l <= j ==> a[k] <= a[l]; // the sub-array a[0..j] is sorted
loop invariant \forall integer k, l; j+2 < k <= l <= i+1 ==> a[k] <= a[l]; // the sub-array a[j+3..i+1] is sorted
loop invariant \forall integer k, l; 0 <= k <= j && j +2 < l <= i+1 ==> a[k] <= a[l]; // every element in a[0..j] is no more then every element in a[j+3..i+1]
loop invariant \forall integer k; j+2 < k <= i+1 ==> x < a[k]; // every element in a[j+3..i+1] is more than x
loop invariant -1 <= j <= i - 1;
loop invariant same_elements{Pre, Here}(t, t, 0, n);
loop invariant \forall integer k; j+2 < k <= i+1 ==> a[k] == t[k];
loop invariant \forall integer k; i+1 < k < n ==> a[k] == t[k];
loop invariant \forall integer k; 0 <= k <= j ==> a[k] == t[k];
loop invariant (t[j+1] == x && t[j+2] == y) || (t[j+1] == y && t[j+2] == x);
loop assigns a[0..n-1],j,t[0..n-1];
loop variant j;
*/
while (j >= 0 && a[j] > x) {
// find the insertion point for x
/*@ ghost L1:;*/
a[j+2] = a[j];
// shift existing content by 2
/*@ ghost int temp = t[j];*/
/*@ ghost t[j] = t[j+2];*/
/*@ ghost t[j+2] = temp;*/
/*@ assert swap{L1, Here}(t, t, 0, j, j+2, n);*/
j = j - 1;
}
/*@ ghost Test:;*/
/*@ assert \forall integer k; j+3 <= k < n ==> a[k] == t[k];*/
/*@ assert same_elements{Pre, Here}(t, t, 0, n);*/
/*@ assert (t[j+1] == x && t[j+2] == y) || (t[j+1] == y && t[j+2] == x);*/
a[j+2] = x;
/*@ assert same_elements{Test, Here}(t, t, 0, n);*/
/*@ assert same_elements{Pre, Here}(t, t, 0, n);*/
/*@ assert \forall integer k; j+3 <= k < n ==> a[k] == t[k];*/
/*@ ghost if(t[j+2] == y){t[j+2] = x;t[j+1] = y;} else {} ;*/
/*@ assert \at(t[j+2],Test) == y ==> swap{Test,Here}(t,t, 0,j+1,j+2,n);*/
/*@ assert \at(t[j+2],Test) != y ==> (\forall integer k; 0 <= k < n ==> \at(t[k],Here) == \at(t[k],Test));*/
/*@ assert t[j+2] == x && t[j+1] == y;*/
/*@ assert same_elements{Test, Here}(t, t, 0, n);*/
/*@ assert same_elements{Pre, Here}(t, t, 0, n);*/
/*@ assert \forall integer k; j+2 <= k < n ==> a[k] == t[k];*/
// store x at its insertion place
// A[j+1] is an available space now
/*@ assert \at(j,Here) == \at(j,Test);*/
/*@ loop invariant \forall integer k, l; 0 <= k <= l <= j ==> a[k] <= a[l]; // the sub-array a[0..j] is sorted
loop invariant \forall integer k, l; j+1 < k <= l <= i+1 ==> a[k] <= a[l]; // the sub-array a[j+2..i+1] is sorted
loop invariant \forall integer k, l; 0 <= k <= j && j +1 < l <= i+1 ==> a[k] <= a[l]; // every element in a[0..j] is no more then every element in a[j+2..i+1]
loop invariant \forall integer k; j+1 < k <= i+1 ==> y <= a[k]; // every element in a[j+2..i+1] is more than x
loop invariant -1 <= j <= \at(j, LoopEntry); // j varies between -1 and its value at the loop entry
loop invariant same_elements{Pre, Here}(t, t, 0, n);
loop invariant \forall integer k; j+1 < k <= i+1 ==> a[k] == t[k];
loop invariant \forall integer k; i+1 < k < n ==> a[k] == t[k];
loop invariant \forall integer k; 0 <= k <= j ==> a[k] == t[k];
loop invariant t[j+1] == y;
loop assigns a[0..n-1],j,t[0..n-1];
loop variant j;
*/
while (j >= 0 && a[j] > y) {
// find the insertion point for y
/*@ ghost L2:;*/
a[j+1] = a[j];
/*@ ghost int temp = t[j];*/
/*@ ghost t[j] = t[j+1];*/
/*@ ghost t[j+1] = temp;*/
/*@ assert swap{L2, Here}(t, t, 0, j, j+1, n);*/
// shift existing content by 1
j = j - 1;
}
/*@ ghost Test2:;*/
/*@ assert \forall integer k; j+2 <= k < n ==> a[k] == t[k];*/
/*@ assert same_elements{Pre, Here}(t, t, 0, n);*/
/*@ assert t[j+1] == y;*/
a[j+1] = y; // store y at its insertion place
/*@ assert same_elements{Test2, Here}(t, t, 0, n);*/
/*@ assert same_elements{Pre, Here}(t, t, 0, n);*/
/*@ assert \forall integer k; j+1 <= k < n ==> a[k] == t[k];*/
i = i+2;
}
if (i == n-1) {
// if length(A) is odd, an extra
int y = a[i];
// single insertion is needed for
int j = i - 1;
// the last element
/*@ loop invariant \forall integer k, l; 0 <= k <= l <= j ==> a[k] <= a[l]; // every element in a[0..j] is more than x
loop invariant \forall integer k, l; j+1 < k <= l < n ==> a[k] <= a[l]; // every element in a[j+2..n-1] is more than x
loop invariant \forall integer k, l; 0 <= k <= j && j +1 < l < n ==> a[k] <= a[l]; // every element in a[0..j] is no more then every element in a[j+2..n-1]
loop invariant \forall integer k; j+1 < k < n ==> y <= a[k]; // every element in a[j+2..n-1] is no less then y
loop invariant -1 <= j <= i-1;
loop invariant same_elements{Pre, Here}(t, t, 0, n);
loop invariant \forall integer k; j+1 < k <= i-1 ==> a[k] == t[k];
loop invariant \forall integer k; i <= k < n ==> a[k] == t[k];
loop invariant \forall integer k; 0 <= k <= j ==> a[k] == t[k];
loop invariant t[j+1] == y;
loop assigns a[0..n-1],j,t[0..n-1];
loop variant j;
*/
while (j >= 0 && a[j] > y) {
/*@ ghost L3:;*/
a[j+1] = a[j];
/*@ ghost int temp = t[j];*/
/*@ ghost t[j] = t[j+1];*/
/*@ ghost t[j+1] = temp;*/
/*@ assert swap{L3, Here}(t, t, 0, j, j+1, n);*/
j = j - 1;
}
/*@ ghost Test3:;*/
/*@ assert \forall integer k; j+2 <= k < n ==> a[k] == t[k];*/
/*@ assert same_elements{Pre, Here}(t, t, 0, n);*/
/*@ assert t[j+1] == y;*/
a[j+1] = y;
/*@ assert same_elements{Test3, Here}(t, t, 0, n);*/
/*@ assert same_elements{Pre, Here}(t, t, 0, n);*/
/*@ assert \forall integer k; j+1 <= k < n ==> a[k] == t[k];*/
}
//@ assert same_array{Pre, Pre}(a, t, 0, n);
//@ assert same_elements{Pre, Here}(t, t, 0, n);
//@ assert same_array{Here, Here}(t, a, 0, n);
//@ assert same_elements{Pre, Here}(a, a, 0, n);
}
| 196 |
// __deref_in and deref_out
#pragma JessieIntegerModel(exact)
/*@ requires \valid(ppi) && \valid(ppo) && \valid(*ppi) && \valid(*ppo);
@ assigns **ppo;
@ ensures **ppo == **ppi;
*/
void deref_OutAndIn(int **ppi, int **ppo) {
**ppo = **ppi;
}
void deref_OutAndIn_test()
{
int a = 5;
int b = 0;
int *pb = &b;
int *pa = &a;
deref_OutAndIn(&pa, &pb);
//@ assert *pa == a;
//@ assert *pb == a;
}
| 13 |
#include <limits.h>
#include <string.h>
/*@
requires ((strlen(x0)>=0) &&
\valid(x0+(0..strlen(x0))));
*/
int matcher_ab_dot_star_ab(char * x0) {
int x2 = 0/*false*/;
int x3 = 1/*true*/;
char *x4 = x0;
/*@
loop invariant ((strlen(x4)>=0) &&
\valid(x4+(0..strlen(x4))));
loop assigns x2, x3, x4;
loop variant ((strlen(x4)+((x2) ? (0) : (1)))+((x3) ? (1) : (0)));
*/
for (;;) {
int x5 = x2;
int x9;
if (x5) {
x9 = 0/*false*/;
} else {
int x7 = x3;
x9 = x7;
}
if (!x9) break;
char *x11 = x4;
char x12 = x11[0];
int x13 = x12 == '\0';
int x16;
if (x13) {
x16 = 0/*false*/;
} else {
int x15 = 'a' == x12;
x16 = x15;
}
int x88;
if (x16) {
char *x17 = x11+1;
char x18 = x17[0];
int x19 = x18 == '\0';
int x22;
if (x19) {
x22 = 0/*false*/;
} else {
int x21 = 'b' == x18;
x22 = x21;
}
int x87;
if (x22) {
int x24 = 0/*false*/;
int x25 = 1/*true*/;
char *x23 = x17+1;
char *x26 = x23;
/*@
loop invariant ((strlen(x26)>=0) &&
\valid(x26+(0..strlen(x26))));
loop assigns x24, x25, x26;
loop variant ((strlen(x26)+((x24) ? (0) : (1)))+((x25) ? (1) : (0)));
*/
for (;;) {
int x27 = x24;
int x31;
if (x27) {
x31 = 0/*false*/;
} else {
int x29 = x25;
x31 = x29;
}
if (!x31) break;
char *x33 = x26;
char x34 = x33[0];
int x35 = x34 == '\0';
int x38;
if (x35) {
x38 = 0/*false*/;
} else {
int x37 = 'a' == x34;
x38 = x37;
}
int x47;
if (x38) {
char *x39 = x33+1;
char x40 = x39[0];
int x41 = x40 == '\0';
int x44;
if (x41) {
x44 = 0/*false*/;
} else {
int x43 = 'b' == x40;
x44 = x43;
}
int x46;
if (x44) {
x46 = 1/*true*/;
} else {
x46 = 0/*false*/;
}
x47 = x46;
} else {
x47 = 0/*false*/;
}
x24 = x47;
int x49 = x24;
if (x49) {
} else {
int x36 = !x35;
x25 = x36;
int x52 = x25;
if (x52) {
x25 = 1/*true*/;
char *x39 = x33+1;
x26 = x39;
} else {
}
}
}
int x85 = x24;
x87 = x85;
} else {
x87 = 0/*false*/;
}
x88 = x87;
} else {
x88 = 0/*false*/;
}
x2 = x88;
int x90 = x2;
if (x90) {
} else {
int x14 = !x13;
x3 = x14;
int x93 = x3;
if (x93) {
char *x17 = x11+1;
x4 = x17;
} else {
}
}
}
int x124 = x2;
return x124;
}
| 39 |
/* run.config
OPT: -cpp-extra-args="-CC" -print
*/
#define X 1 /* multi-line
comment */ + 2 + /*
bla
*/ 3
#define Y 5 + \
6 + \
7
/*@ ensures \result == X+Y; */
int main(void)
{
return X+Y;
}
| 3 |
#define EQUAL_B_SIZE 5
#define EQUAL_A_SIZE 5
#define ZEROS_A_SIZE 7
/*@ requires \valid(a+(0.. EQUAL_A_SIZE -1)) && EQUAL_A_SIZE >=0 && \valid(b+(0.. EQUAL_B_SIZE -1)) && EQUAL_B_SIZE >=0;
assigns \nothing;
ensures equal_post : \result ==> (\exists int i; 0 <= i <= EQUAL_A_SIZE-1 && a[i] == b[0]) ;
*/
int equal(int a[EQUAL_A_SIZE], int b[EQUAL_B_SIZE]) {
int res = 1;
int i;
for (i = 0; i < EQUAL_A_SIZE; i++) {
if (a[i] != b[i])
res = 0;
}
return res;
}
/*@ requires \valid(a+(0.. ZEROS_A_SIZE -1)) && ZEROS_A_SIZE >=0;
assigns a[0.. ZEROS_A_SIZE -1];
ensures zeros_post : \forall int it_x; (0 <= it_x <= ZEROS_A_SIZE-1) ==> \let x=a[it_x];(x == 0) ;
*/
void zeros(int a[ZEROS_A_SIZE]){
int i;
for (int i=0;i<ZEROS_A_SIZE;i++){
a[i]=0;
}
}
| 3 |
/*@
requires n>0;
requires 0<=k<n;
requires\valid(a+ (0..n-1));
ensures\forall integer i;
0<= i<=k ==>a[k]>=a[i];
*/
void bubbleinnerloop(int a[], int n, int k)
{
/*@
loop invariant\forall integer i;
0<= i<j ==> a[j]>=a[i];loop invariant 0<=j<=k;
loop assigns j,a[0..j+1];
loop variant k-j;
*/
for (int j = 0; j < k; j++)
{
if (a[j] > a[j + 1])
{
int temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
| 23 |
#include <limits.h>
/*@
requires (x0>0);
assigns \nothing;
ensures ((0<=\result) &&
(\result<x0));
*/
int picker_first(int x0) {
return 0;
}
/*@
requires ((x7>0) &&
\valid(x6+(0..x7-1)));
assigns \nothing;
*/
int pick_first_element(int * x6, int x7) {
int x9 = picker_first(x7);
int x10 = x6[x9];
return x10;
}
/*@
requires ((x16>0) &&
\valid(x15+(0..x16-1)));
assigns \nothing;
*/
int pick_first_directly(int * x15, int x16) {
int x18 = x15[0];
return x18;
}
/*@
requires (x23>0);
assigns \nothing;
ensures ((0<=\result) &&
(\result<x23));
*/
int picker_last(int x23) {
int x25 = x23 - 1;
return x25;
}
/*@
requires ((x31>0) &&
\valid(x30+(0..x31-1)));
assigns \nothing;
*/
int pick_last_element(int * x30, int x31) {
int x33 = picker_last(x31);
int x34 = x30[x33];
return x34;
}
/*@
requires ((x40>0) &&
\valid(x39+(0..x40-1)));
assigns \nothing;
*/
int pick_last_directly(int * x39, int x40) {
int x42 = x40 - 1;
int x43 = x39[x42];
return x43;
}
| 32 |
#include <string.h>
/*@ requires \valid(s + (0..n));
requires valid_string(s);
requires c != 0;
behavior no_padding:
assumes strlen(s) >= n;
assigns \nothing;
behavior padding:
assumes strlen(s) < n;
ensures valid_string(s);
ensures \let l = strlen{Pre}(s); \let p = n - l;
(\forall integer x; 0 <= x < p ==> s[x] == c) &&
memcmp{Pre, Post}(s, s + p, l + 1) == 0 &&
strlen(s) == n;
assigns s[0 .. n];
complete behaviors;
disjoint behaviors;
*/
void leftpad(char c, size_t n, char *s) {
size_t l = strlen(s);
if (n > l) {
size_t p = n - l;
// This loop is equivalent to memmove(s+p, s, l+1)
/*@ loop invariant x_range: 0 <= x <= l;
loop invariant s_state: \forall integer i; 0 <= i <= n ==>
(i <= x+p ==> s[i] == \at(s[i], LoopEntry)) &&
(i > x+p ==> s[i] == \at(s[i-p], LoopEntry));
loop assigns x, s[p..n];
loop variant x;
*/
for (size_t x = l;; x--) {
s[x+p] = s[x];
if (x == 0) {
break;
}
}
// These assertions are not strictly necessary, but they speed up the verification
//@ assert same_chars: memcmp{Pre, Here}(s, s+p, l+1) == 0 && s[n] == 0;
//@ assert valid_str: valid_string(s+p);
//@ assert same_len: strlen(s+p) == l;
// This loop is equivalent to memset(s, c, p)
/*@ loop invariant x_range2: 0 <= x <= p;
loop invariant still_same: memcmp{Pre, LoopCurrent}(s, s+p, l+1) == 0 && s[n] == 0;
loop invariant valid_grows: valid_string(s + p - x);
loop invariant padding_grows: \forall integer i; p - x <= i < p ==> s[i] == c;
loop assigns x, s[0..p-1];
loop variant p - x;
*/
for (size_t x = 0; x < p; x++) {
s[p-1-x] = c;
}
}
}
| 32 |
/*@ requires \valid(p) && \valid(q);
ensures \result >= *p && \result >= *q;
ensures \result == *p || \result == *q;
assigns \nothing;
*/
int max_ptr ( int *p, int *q ) {
if ( *p >= *q )
return *p ;
return *q ;
}
| 10 |
#include <stdio.h>
#include <stdlib.h>
/*@
requires \valid_read(a + (0..n-1));
requires \valid_read(b + (0..n-1));
requires n >= 0;
assigns \nothing;
behavior if_equal:
assumes \forall integer k; 0<=k<n ==> a[k] == b[k];
ensures \result == 1;
behavior if_not_equal:
assumes \exists integer k;0<=k<n && a[k] != b[k];
ensures \result == 0;
*/
int equal(int *a, int n, int *b){
int i;
i = 0;
/*@
loop invariant 0 <= i <= n;
loop invariant \forall integer k; 0 <= k < i ==> a[k] == b[k];
loop assigns i;
loop variant n-i;
*/
for (i = 0; i < n; i++) {
if (a[i] != b[i]){
return 0;
}
}
return 1;
}
int main(){
int a[] = {1,2,3,4,5};
int b[] = {1,2,3,4,5};
equal(a,5,b);
return 0;
}
| 24 |
/* Run with:
*
* frama-c -wp -wp-prover alt-ergo -wp-rte -wp-print -wp-timeout 300 -wp-verbose 0 ex9_final.c -then -report
*
* Tested with Frama-C Sulfur-20171101.
* Η ορθότητα του προγράμματος εξασφαλίζεται πρώτον από το loop invariant της γραμμής 52, που λέει ουσιαστικά ότι, από
* όλες τις θέσεις του a που η επανάληψη έχει προσπεράσει, καμία τιμή σε αυτές τις θέσεις
* δεν έχει αντίγραφο σε προηγούμενη θέση του a, και δεύτερον από το ensures της γραμμής 38, της οποίας το predicate
* ελέγχει για την ορθότητα του αποτελέσματος που επιστρέφεται από τη συνάρτηση.
*/
#include <stdbool.h>
#define MAXV 1000000
/*@ predicate noDouble{L}(int n, int *a) =
@ \forall integer i; 0 <= i < n-1 ==>
@ \forall integer j; i+1 <= j < n ==> \at(a[i], L) != \at(a[j], L);
@*/
/*@ predicate existsDoubleRes{L}(int n, int *a, int res) =
@ \exists integer i, j; 0 <= i < j < n ==> res == \at(a[i], L) && res == \at(a[j], L);
@*/
/*@ predicate validateResult{L}(int n, int *a, int res) =
@ res == 0 ?
@ noDouble{L}(n, a) :
@ existsDoubleRes{L}(n, a, res);
@*/
/*@ requires 0 < N <= MAXV;
@ requires \valid(a + (0..(N-1)));
@ requires \forall integer i; 0 <= i < N ==> 1 <= a[i] <= MAXV;
@ assigns \nothing;
@ ensures 0 <= \result <= MAXV;
@ ensures validateResult(N, a, \result);
@*/
int findDouble(int N, int a[]) {
bool f[MAXV];
/*@ loop assigns i, f[0..(MAXV-1)];
@ loop invariant 1 <= i <= (MAXV+1);
@ loop invariant \forall integer k; 1 <= k < i ==> f[k-1] == false;
@ loop variant MAXV-i;
@*/
for (int i = 1; i <= MAXV; ++i)
f[i-1] = false;
/*@ loop assigns i, f[0..(MAXV-1)];
@ loop invariant 0 <= i <= N;
@ loop invariant \forall integer k; 0<=k<i ==> f[a[k]-1] == true;
@ loop invariant \forall integer k; 0 < k < i ==>
@ \forall integer l; 0 <= l < k ==> a[k] != a[l];
@ loop variant N-i;
@*/
for (int i = 0; i < N; ++i)
if (f[a[i]-1])
return a[i];
else
f[a[i]-1] = true;
return 0;
}
| 39 |
/*@ requires n >= 0;
requires \valid(a + (0..n-1));
assigns \nothing;
behavior empty:
assumes n == 0;
ensures \result == 0;
behavior not_empty:
assumes 0 < n;
ensures 0 <= \result < n;
ensures \forall integer i; 0 <= i < n ==> a[i] <= a[\result];
ensures \forall integer i; 0 <= i < \result ==> a[i] < a[\result];
complete behaviors;
disjoint behaviors;
*/
int max_element(int* a, int n)
{
if (n == 0) {
return 0;
}
int max = 0;
/*@
loop invariant 0 <= i <= n;
loop invariant 0 <= max < n;
loop invariant \forall integer k; 0 <= k < i ==> a[k] <= a[max];
loop invariant \forall integer k; 0 <= k < max ==> a[k] < a[max];
loop assigns max, i;
loop variant n-i;
*/
for (int i = 1; i < n; i++) {
if (a[max] < a[i]) {
max = i;
}
}
return max;
}
/*@ requires n > 0;
requires \valid(p + (0..n-1));
assigns \nothing;
ensures \forall integer i; 0 <= i <= n-1 ==> \result >= p[i];
ensures \exists integer e; 0 <= e <= n-1 && \result == p[e];
*/
int max_seq(int* p, int n)
{
return p[max_element(p, n)];
}
| 36 |
/*@ requires \valid(p) && \valid(q);
requires -10000<*p<10000 && -10000<*q<10000;
assigns *p;
assigns *q;
ensures *p==\old(*q);
ensures *q==\old(*p);
*/
void swap(int *p, int *q){
int sum=*p + *q;
*p=sum-*p;
*q=sum-*p;
}
| 18 |
/*@ requires -2147483648<a+b<2147483647;
ensures \result==a+b;
*/
int add(int a,int b){
return a+b ;
}
| 5 |
/*@
requires n>0;
requires \valid_read(a+(0..n-1));
requires \valid_read(b+(0..n-1));
behavior same:
assumes \forall integer i;
0<=i<n ==> a[i] == b[i];
ensures \result == 1;
behavior not_same:
assumes \exists integer i;
0<=i<n && a[i] != b[i];
ensures \result == 0;
*/
int is_same(int a[],int b[],int n) {
/*@
loop invariant \forall integer j;
0<=j<i ==> a[j] == b[j];
loop invariant 0<=i<=n;
loop assigns i;
loop variant n-i;
*/
for(int i=0;i<n;i++) {
if(a[i] != b[i])
return 0;
}
return 1;
}
| 14 |
#include "stddef.h"
// the 'pos' pre-condition forbids to pass empty arrays to the function:
// otherwise, we would need to make a special case in the code, as initializing
// 'high' with 'length - 1' is not a good idea if 'length' is 0
/*@
requires pos: length > 0;
requires array: \valid_read(a + (0 .. length - 1));
requires sorted: \forall integer i, j; 0 <= i < j < length ==> a[i] <= a[j];
assigns \nothing;
behavior has_key:
assumes has_key: \exists integer i; 0 <= i < length && a[i] == key;
ensures 0 <= \result < length;
ensures a[\result] == key;
behavior no_key:
assumes no_key: \forall integer i; 0 <= i < length ==> a[i] != key;
ensures \result == length;
complete behaviors;
disjoint behaviors;
*/
size_t binary_search(char* a, size_t length, char key) {
size_t low = 0;
size_t high = length - 1;
/*@ loop invariant bounds: 0 <= low <= high + 1 <= length;
loop invariant small_vals: \forall integer i; 0<=i<low ==> a[i] < key;
loop invariant big_vals:
\forall integer i; high < i < length ==> a[i] > key;
loop assigns high, low;
loop variant high - low;
*/
while (high >= low) {
// There was a quite well known bug in the original version of the code:
// for big arrays, computing (low + high) / 2 might overflow when doing
// the addition, resulting in an incorrect middle index.
size_t middle = low + (high - low) / 2;
if (a[middle] == key) return middle;
if (a[middle] < key) low = middle + 1;
else {
// another subtle issue of the original code: if we're looking for a
// small 'key', 'middle' will eventually become '0', in which case we know
// that we won't find 'key'. And of course, we do not want to compute
// 'middle - 1' there
if (middle == 0) return length;
else high = middle - 1;
}
}
return length;
}
| 22 |
#include <limits.h>
/*@
assigns \nothing;
ensures (((\result>=x0) &&
(\result>=x1)) &&
((\result==x0) || (\result==x1)));
*/
int max(int x0, int x1) {
int x3 = x0 > x1;
int x4;
if (x3) {
x4 = x0;
} else {
x4 = x1;
}
return x4;
}
| 5 |
#include <limits.h>
/*@
requires ((((((((0<x0) &&
(x0<100)) &&
(0<x1)) &&
(x1<100)) &&
(0<=x2)) &&
(0<=x3)) &&
(x2<x0)) &&
(x3<x1));
assigns \nothing;
ensures ((0<=\result) &&
(\result<(x0*x1)));
*/
int index(int x0, int x1, int x2, int x3) {
int x5 = x2 * x1;
int x6 = x5 + x3;
return x6;
}
/*@ predicate inv_matrix_Boolean(int * x36, int x37, int x38) = (((((x37<100) &&
(x38<100)) &&
(0<x37)) &&
(0<x38)) &&
(((x37*x38)>0) &&
\valid(x36+(0..(x37*x38)-1))));*/
/*@
requires (((inv_matrix_Boolean(x79,x80,x81) &&
inv_matrix_Boolean(x82,x83,x84)) &&
inv_matrix_Boolean(x85,x86,x87)) &&
((((x80==x83) &&
(x80==x86)) &&
(x81==x84)) &&
(x81==x87)));
ensures ((inv_matrix_Boolean(x79,x80,x81) &&
inv_matrix_Boolean(x82,x83,x84)) &&
inv_matrix_Boolean(x85,x86,x87));
*/
void add(int * x79, int x80, int x81, int * x82, int x83, int x84, int * x85, int x86, int x87) {
/*@
loop invariant 0<=x92<=x86;
loop assigns x92, x85[(0..(x86*x87)-1)];
loop variant x86-x92;
*/
for(int x92=0; x92 < x86; x92++) {
/*@
loop invariant 0<=x94<=x87;
loop assigns x94, x85[(0..(x86*x87)-1)];
loop variant x87-x94;
*/
for(int x94=0; x94 < x87; x94++) {
int x95 = index(x80,x81,x92,x94);
int x96 = x79[x95];
int x97 = index(x83,x84,x92,x94);
int x98 = x82[x97];
int x99 = x96 || x98;
int x100 = index(x86,x87,x92,x94);
x85[x100] = x99;
}
}
}
/*@
requires ((inv_matrix_Boolean(x130,x131,x132) &&
inv_matrix_Boolean(x133,x134,x135)) &&
((x131==x134) &&
(x132==x135)));
ensures (inv_matrix_Boolean(x130,x131,x132) &&
inv_matrix_Boolean(x133,x134,x135));
*/
void scalar_mult(int x129, int * x130, int x131, int x132, int * x133, int x134, int x135) {
/*@
loop invariant 0<=x140<=x134;
loop assigns x140, x133[(0..(x134*x135)-1)];
loop variant x134-x140;
*/
for(int x140=0; x140 < x134; x140++) {
/*@
loop invariant 0<=x142<=x135;
loop assigns x142, x133[(0..(x134*x135)-1)];
loop variant x135-x142;
*/
for(int x142=0; x142 < x135; x142++) {
int x145;
if (x129) {
int x143 = index(x131,x132,x140,x142);
int x144 = x130[x143];
x145 = x144;
} else {
x145 = 0/*false*/;
}
int x146 = index(x134,x135,x140,x142);
x133[x146] = x145;
}
}
}
| 66 |
/*@
requires \valid(a) && \valid_read(b);
requires \separated(a, b);
assigns *a;
ensures \old(*b) ==> *a == 0;
ensures ! \old(*b) ==> *a == \old(*a);
ensures *b == \old(*b);
*/
void reset_1st_if_2nd_is_true(int* a, int const* b){
if(*b) *a = 0 ;
}
int main(){
int a = 5 ;
int x = 0 ;
reset_1st_if_2nd_is_true(&a, &x);
//@ assert a == 5 ;
//@ assert x == 0 ;
int const b = 1 ;
reset_1st_if_2nd_is_true(&a, &b);
//@ assert a == 0 ;
//@ assert b == 1 ;
}
| 18 |
// pour INT_MIN
#include <limits.h>
// valeur absolue
/*@
requires a != INT_MIN;
ensures \result >= 0;
ensures \result == a || \result == -a;
*/
int abs(int a)
{
return (a > 0) ? a : -a;
}
| 5 |
// __in struct pointer
typedef struct s
{
int a;
int b;
} S;
/*@ requires \valid(ps);
@ assigns ps->b;
*/
void f6(S *ps)
{
if (ps)
{
if (ps->a == 0)
{
ps->b = 0;
}
else
{
ps->b = 1;
}
}
}
| 7 |
/*@
ensures 0 <= \result <= 1;*/
// */
int loop(unsigned N) {
int c = 0;
unsigned i;
/*@
loop invariant 0 <= c <= 1;
loop invariant i <= N;
loop variant N - i;
*/
for (i = 0; i < N; ++i) {
c = 1 - c;
}
return c;
}
| 10 |
/*@ axiomatic GCD {
@ logic integer gcd(integer x, integer y);
@ axiom gcd_equal:
@ \forall integer x;
@ (x > 0) ==> gcd(x, x) == x;
axiom gcd_comm:
\forall integer x, integer y;
(x > 0 && y > 0) ==> gcd(x, y) == gcd(y, x);
axiom gcd_add:
\forall integer x, integer y;
(x > 0 && y > 0) ==> gcd(x + y, y) == gcd(x, y);
@ }
*/
/*@ requires a > 0 && b > 0;
@ assigns \nothing;
@ ensures \result == gcd(a, b);
*/
int euclid(int a, int b) {
int x = a;
int y = b;
/*@ loop invariant x > 0 && y > 0;
@ loop invariant gcd(x, y) == gcd(a,b);
@ loop assigns x, y;
@ loop variant \max(x, y);
*/
while (x != y) {
if (x > y) {
x -= y;
} else {
y -= x;
}
}
return x;
}
| 15 |
#define SPEC_INT_MIN -2147483648
#define SPEC_INT_MAX 2147483647
/*@ requires \true;
requires a > SPEC_INT_MIN; // Найдите ошибку в спецификации. Ответ.
requires b > SPEC_INT_MIN; // Найдите ошибку в спецификации. Ответ.
assigns \nothing;
ensures \result == \abs(\abs(a) - \abs(b));
*/
unsigned distance_abs(int a, int b)
{
unsigned ua = a < 0 ? -a : a;
unsigned ub = b < 0 ? -b : b;
//unsigned ua = a < 0 ? ((unsigned)-((long)a)) : a; // Найдите ошибку в реализации. Ответ.
//unsigned ub = b < 0 ? ((unsigned)-((long)b)) : b; // Найдите ошибку в реализации. Ответ.
return ua > ub ? ua - ub : ub - ua;
}
#ifdef OUT_OF_TASK
#include <stdio.h>
int main(void)
{
printf("res: %u\n", distance_abs(3,30));
printf("res: %u\n", distance_abs(-5,-20));
printf("res: %u\n", distance_abs(7,-10));
printf("res: %u\n", distance_abs(-2,15));
return 0;
}
#endif
| 11 |
/*@ requires n>0;
requires \valid(t+(0..n-1));
ensures \forall integer i; 0<=i<n ==> t[\result]<=t[i];
ensures \exists integer i; 0<=i<n && t[\result]<=t[i];
*/
int minarray(int t[],int n) {
int index=0;
/*@ loop invariant 0<=i<=n;
loop invariant 0<=index<n;
loop invariant \forall integer j; 0<=j<i ==> t[index]<=t[j];
loop variant n-1-i;
*/
for(int i=0;i<n;i++) {
if ( t[i] < t[index] ) index = i;
}
return index;
}
| 11 |
/*@ predicate inInterval(integer a, integer b, integer c) = a >= b && b <= c;
predicate fourInOrder(integer a, integer b, integer c, integer d) = inInterval(b,a,c) && inInterval(c,b,d);
predicate controlledEquality(integer a, integer b, boolean c) = a == b || c;
*/
/*@ requires inInterval(a,b,c);
requires inInterval(c,a,d);
ensures fourInOrder(\result,a,c,d);
*/
int toto(int a, int b, int c, int d){
return b;
}
| 3 |
// Note axiomatization with integer type, rather than int.
/* inductive isfact(integer n, integer r) {
@ case isfact0:
@ isfact(0,1);
@ case isfactn:
@ \forall integer n, integer f;
@ isfact(n-1,f) ==> isfact(n,f*n);
@ }
@*/
/* axiomatic factorial {
@
@ logic integer fact (integer n);
@
@ axiom fact1:
@ \forall integer n; isfact (n,fact(n));
@
@ axiom fact2:
@ \forall integer n, integer f; isfact (n,f) ==> f==fact(n);
@ }
@
@*/
/*@ logic integer fact (integer n) =
@ (n == 0) ? 1 : n * fact(n-1);
@
@*/
/*@ requires n >= 0;
@ ensures fact(n) == \result;
@ assigns \nothing;
@*/
int factf (int n)
{
int f = 1;
int i = 1 ;
/*@ loop invariant 1 <= i <= n+1 && f == fact(i-1);
@ loop assigns i, f;
@ loop variant n-i;
@*/
while (i <= n) {
f = f * i;
i = i + 1;
}
return f;
}
| 3 |
/*@ requires i > sizeof(int);
@ ensures \result > sizeof(i);
@*/
int f(int i) {
return i;
}
| 3 |
#include <limits.h>
/*@ predicate inv_vec_Int(int * x0, integer x1) = ((x1==0) || ((x1>0) &&
\valid(x0+(0..x1-1))));*/
/*@ predicate eq_vec_Int(int * x15, int x16, int * x17, int x18) = ((x16==x18) &&
(\forall int x22; (0<=x22<x16) ==> (x15[x22]==x17[x22])));*/
/*@
requires (inv_vec_Int(x15,x16) &&
inv_vec_Int(x17,x18));
assigns \nothing;
ensures (inv_vec_Int(x15,x16) &&
inv_vec_Int(x17,x18));
ensures \result <==> eq_vec_Int(x15, x16, x17, x18);
*/
int eq_vec_Int(int * x15, int x16, int * x17, int x18) {
int x20 = x16 == x18;
int x31;
if (x20) {
int x30 = 1;
/*@ loop invariant (0 <= x23 <= x16);
loop invariant \forall int x22; (0 <= x22 < x23) ==> (x15[x22]==x17[x22]);
loop invariant x30==1;
loop assigns x23, x30;
loop variant (x16-x23); */
for (int x23 = 0; x23 < x16; x23++) {
int x27 = x15[x23];
int x28 = x17[x23];
int x29 = x27 == x28;
if (!x29) { x30 = 0; break; }
}
x31 = x30;
} else {
x31 = 0/*false*/;
}
return x31;
}
| 20 |
/*@
ensures (((((b*b)-4*a*c)>=0)&&(\result==0))||((((b*b)-4*a*c)<0)&&(\result==1)));
*/
int check(int a, int b, int c)
{
if(((b*b)-(4*a*c))>=0)
return 0;
else
return 1;
}
int main()
{
int ret = check(2,1,1);
return 0;
}
| 20 |
#include <stddef.h>
/*@ requires \valid(s + (0 .. length - 1));
requires \valid(stack + (0 .. length - 1));
requires \valid(left + (0 .. length - 1));
requires \separated(stack + (0 .. length - 1),left + (0 .. length - 1));
requires \separated(stack + (0 .. length - 1), s + (0 .. length - 1));
requires \separated(left + (0 .. length - 1), s + (0 .. length - 1));
assigns stack[0 .. length - 1], left[0 .. length - 1];
ensures wf_left: \forall integer i; 0 <= i < length ==> 0 <= left[i] <= i;
ensures left_small:
\forall integer i; 0 <= i < length ==> 0 < left[i] ==>
left[i] > 0 ==> s[left[i]-1] < s[i];
ensures left_smallest:
\forall integer i; 0 <= i < length ==>
\forall integer j; left[i] <= j < i ==> s[j] >= s[i];
*/
void neighbor(int* s, size_t length, size_t* stack, size_t* left) {
size_t sidx = 0;
/*@ loop invariant s_untouched:
\forall integer idx; 0 <= idx < length ==> s[idx] == \at(s[idx],Pre);
loop invariant 0 <= x <= length;
loop invariant 0 <= sidx <= x;
loop invariant stack_left:
\forall integer i; 0 <= i < sidx ==> 0 < stack[i] <= x;
loop invariant wf_left:
\forall integer i; 0 <= i < x ==> 0 <= left[i] <= i;
loop invariant left_small:
\forall integer i; 0 <= i < x ==> left[i] > 0 ==> s[left[i] - 1] < s[i];
loop invariant left_smallest:
\forall integer i; 0 <= i < x ==>
\forall integer j; left[i] <= j < i ==> s[j] >= s[i];
loop invariant stack_order:
\forall integer i, j; 0<= i < j < sidx ==> 0 <= stack[i] < stack[j];
loop invariant stack_sorder:
\forall integer i, j;
0<= i < j < sidx ==> s[stack[i]-1] < s[stack[j]-1];
loop invariant s_begin:
sidx > 0 ==>
\forall integer i; 0<=i<stack[0] ==> s[i] >= s[stack[0] - 1];
loop invariant step_n:
x > 0 ==> sidx > 0 && stack[sidx - 1] == x;
loop invariant stack_summary:
\forall integer i; 0<= i < sidx - 1 ==>
\forall integer j; stack[i] <= j < stack[i+1]-1 ==>
s[j] >= s[stack[i+1]-1];
loop invariant stack_push: sidx > 0 ==> stack[sidx-1] == x;
loop assigns x, sidx, stack[0 .. length - 1], left[0 .. length - 1];
loop variant length - x;
*/
for (size_t x = 0; x < length; x++) {
/*@
loop invariant s_untouched_inner:
\forall integer idx; 0 <= idx < length ==> s[idx] == \at(s[idx],Pre);
loop invariant 0 <= sidx <= \at(sidx,LoopEntry);
loop invariant left_bigger:
sidx > 0 ==>
\forall integer i;
stack[sidx-1] <= i < x ==> s[i] >= s[x];
loop invariant stack_empty:
sidx == 0 ==>
\forall integer i; 0 <= i < x ==> s[i] >= s[x];
loop assigns sidx;
loop variant sidx;
*/
while (sidx > 0 && s[stack[sidx-1]-1] >= s[x]) sidx--;
if (sidx == 0) {
left[x] = 0;
} else {
/*@ assert head_ok:
\forall integer i; stack[sidx-1]<=i<x ==> s[i] >= s[x];
*/
left[x] = stack[sidx - 1];
}
//@ assert a1: left[x] > 0 ==> s[left[x] - 1] < s[x];
label:
stack[sidx] = x + 1;
/*@ assert s_untouched:
\forall integer idx; 0 <= idx < length ==> s[idx] == \at(s[idx],Pre);
*/
//@ assert same: left[x] == \at(left[x], label);
//@ assert a2: left[x] > 0 ==> s[left[x] - 1] < s[x];
sidx++;
}
}
| 62 |
/* run.config
DONTRUN: linked with first which is the real test.
*/
/*@ behavior b:
requires \valid(third);
ensures \result == 0;*/
int bar(int *third) {
third=(int*)*third;
return 0;
}
| 4 |
/*@ predicate pcond1(integer p) = (p>0)?\true:\false ;
@ predicate pcond2(integer p) = (p<10)?\true:\false ;
@*/
/*@
//// ensures (pcond1(x) && pcond2(y)) ==> \result == 1 ;
@ ensures \result == 1 <==> pcond1(x) && pcond2(y);
@*/
int ftest1(int x, int y)
{
return (x>0 && y<10);
}
/*@ predicate pcond3(integer p) = p > 0;
@ predicate pcond4(integer p) = p < 10;
@*/
/*@ behavior ok:
@ assumes pcond3(x) && pcond4(y);
@ ensures \result == 1;
@ behavior ko:
@ assumes !pcond3(x) || !pcond4(y);
@ ensures \result == 0;
@*/
int ftest2(int x, int y)
{
return (x>0 && y<10);
}
| 7 |
/*@ ensures *q == \old(*p) && *p == \old(*q) ;
assigns *p,*q;
*/
void f (int *p,int*q) {
int t = *p;
*p = *q;
*q = t;
return;
}
| 7 |
/*@ requires n > 0;
@ ensures \result == \max(0,n-1,\lambda integer k; t[k]);
@*/
double max_array(double t[], int n) {
double m; int i=0;
goto L;
do {
if (t[i] > m) { L: m = t[i]; }
/*@ invariant
@ 0 <= i < n && m == \max(0,i,\lambda integer k; t[k]);
@*/
i++;
}
while (i < n);
return m;
}
| 1 |
#include<stdio.h>
enum kind {vowel,consonent};
/*@
requires c>='a' && c<='z';
behavior vowel:
assumes c=={'a','e','i','o','u'};
ensures \result==vowel;
behavior consonent:
assumes c=={'b','c','d','f','g','h','j','k','l','m','n','p','q','r','s','t','v','w','x','y','z'};
ensures \result==consonent;
disjoint behaviors;
*/
enum kind kind_of_letter(char c){
if(c=='a' || c=='e' || c=='i' || c=='o' || c=='u'){
return vowel;
}
else{
return consonent;
}
}
/*@
behavior q1:
assumes x>=0 &&y>0;
ensures \result==1;
behavior q2:
assumes x<0 &&y>=0;
ensures \result==2;
behavior q3:
assumes x<=0 &&y<0;
ensures \result==3;
behavior q4:
assumes x>0 &&y<=0;
ensures \result==4;
behavior q0:
assumes x==0 &&y==0;
ensures \result==0;
complete behaviors;
*/
int quadrant(int x,int y){
/*
*Basically remember to check for the logical constrains of quadrants
*/
if(x>=0 && y>0) return 1;
else if (x<0 && y>=0) return 2;
else if (x<=0 && y<0) return 3;
else if (x==0 && y==0) return 0;
else return 4;
}
| 13 |
/*@
predicate Positive(int a) = 0 < a;
*/
/*@
predicate Positive(short a) = 0 < a;
*/
/*@
requires Positive(a);
assigns \nothing;
ensures Positive(\result);
*/
int foo(short a)
{
return a;
}
struct Pair
{
int first, second;
};
typedef struct Pair Pair;
/*@
predicate Positive(Pair p) = Positive(p.first) && Positive(p.second);
*/
/*@
requires Positive(a);
assigns \nothing;
ensures Positive(\result);
*/
Pair bar(int a)
{
Pair p;
p.first = a;
p.second = a;
return p;
}
| 9 |
// Side effects can be controlled on an individual basis.
#include <limits.h>
extern int a;
/*@
requires x > INT_MIN;
assigns a; // allow assignment to a (but only to a).
ensures 0 <= x ==> \result == x;
ensures 0 > x ==> \result == -x;
*/
int abs_int(int x)
{
a = x;
return (x >= 0) ? x : -x;
}
| 8 |
/*@
requires \valid(a) && \valid(b);
assigns *a, *b;
ensures *a == \old(*b) && *b == \old(*a);
*/
void swap(int* a, int* b) {
int tmp = *a;
*a = *b;
*b = tmp;
}
int main(){
int a = 37;
int b = 91;
swap(&a, &b);
}
| 12 |
/*@ //requires \nothing;
requires \true;
assigns \nothing;
ensures \result == \max(a, b) - \min(a, b);
*/
unsigned distance(unsigned a, unsigned b)
{
return (a > b) ? (a - b) : (b - a);
}
#ifdef OUT_OF_TASK
#include <stdio.h>
int main(void)
{
printf("res: %d\n", distance(100, 80));
return 0;
}
#endif
| 5 |
#include <limits.h>
/*@
requires \valid(x0+(0..1));
ensures ((x0[0]==\old(x0[1])) &&
(x0[1]==\old(x0[0])));
*/
void array_swap(int * x0) {
int x2 = x0[0];
int x3 = x0[1];
x0[0] = x3;
x0[1] = x2;
}
| 7 |
/*@
requires \valid(p);
ensures *p == 0;
*/
void main(int*p) {
*p = 0;
CEA_DUMP();
}
| 7 |
/*@
requires d > 0;
assigns \nothing;
ensures 0 <= \result < d;
*/
static inline
unsigned int inverse_modulo(unsigned int n, unsigned int d)
{
return d - 1 - (n % d);
}
| 5 |
/*@ ensures \result >= x && \result >= y;
ensures \result == x || \result == y;
*/
int max (int x, int y) { return (x > y) ? x : y; }
| 4 |
/*@ predicate sorted(int *t,integer i,integer j) =
@ \forall integer k, integer l; i <= k < l <= j ==> t[k] <= t[l];
@*/
/*@ requires N >= 1 && \valid(A+(0..N-1));
@ assigns A[0..N-1];
@ ensures sorted(A,0,N-1);
@*/
void insertionSort(int A[], int N) {
int i, j, key;
/*@ loop invariant
@ 1 <= j <= N && sorted(A, 0, j-1);
@ loop assigns
@ j, key, i, A[0..N-1];
@ loop variant
@ N-j;
@*/
for (j=1 ; j<N ; j++) {
key = A[j];
i = j-1;
/*@ loop invariant -1 <= i <= j-1;
@ loop invariant i == j-1 ==> sorted(A, 0, j-1);
@ loop invariant i < j-1 ==> sorted(A, 0, j);
@ loop invariant \forall int k; i < k < j ==> A[k] > key;
@ loop assigns i, A[1..j];
@ loop variant i;
@*/
while (i>=0 && A[i] > key) {
A[i+1] = A[i];
i--;
}
A[i+1] = key;
}
}
| 36 |
#pragma JessieIntegerModel(math)
/*@ logic integer POW (integer x, integer n) =
@ (n > 0) ? x * POW(x, n-1)
@ : 1;
@*/
/*@ requires n >= 0;
@ ensures \result == POW(x, n);
@*/
unsigned long pow (unsigned long x, unsigned int n)
{
unsigned long r;
/*@ loop invariant n >= 0;
@ loop invariant r * POW(x, n) == \at(POW(x, n), Pre);
@ loop variant n;
@*/
for (r = 1; n > 0; n /= 2, x = x*x)
if (n % 2 == 1)
r *= x;
return r;
}
/*@ lemma pow_zero:
@ \forall integer x;
@ POW(x, 0) == 1;
@*/
/*@ lemma pow_square_odd:
@ \forall integer x, integer n;
@ n >= 0 ==>
@ n % 2 == 1 ==>
@ POW(x, n) == x * POW(x*x, n/2);
@*/
/*@ lemma pow_square_even:
@ \forall integer x, integer n;
@ n >= 0 ==>
@ n % 2 == 0 ==>
@ POW(x, n) == POW(x*x, n/2);
@*/
| 36 |
/*@ requires \pointer_comparable((void*)p,(void*)q) && \is_finite(*p) ; */
void f(float*p, char const * q) {
return;
}
| 2 |
/*@
requires n > 0;
requires \valid(a+(0..n-1));
requires \valid(b+(0..n-1));
assigns \nothing;
behavior same:
assumes \forall integer k; 0 <= k < n ==> a[k] == b[k];
ensures \result==1;
behavior different:
assumes \exists integer k; 0 <= k < n && a[k] != b[k];
ensures \result==0;
complete behaviors same, different;
disjoint behaviors same, different;
*/
/* NOTE : the opposite of the proposition
\forall integer k; 0 <= k < n ==> a[k] == b[k]
is the proposition
\exists integer k; 0 <= k < n && a[k] != b[k]
INDEED !
- the negation of (A ==> B) is A && (negation of B)
- seen from another point of view, "the negation of forall k, A"
is "exists k, the negation of A"
(this is 100% logical if you think of it a bit)
*/
int equal(const int* a, int n, const int* b) {
/*@
loop invariant 0 <= i <= n;
loop invariant \forall integer k; 0 <= k < i ==> a[k] == b[k];
loop assigns i;
loop variant n-i;
*/
for(int i=0; i<n; i++) {
if (a[i] != b[i]) {
return 0;
}
}
return 1;
}
| 19 |
/*@ requires \valid(t+(0..n-1)) && n > 0;
@ ensures (\forall integer i; 0 <= i < n ==> \result <= t[i]) &&
@ (\exists integer i; 0 <= i < n && \result == t[i]);
@ assigns \nothing;
*/
int getMin(int t[], int n) {
int res = t[0];
/*@ loop invariant 1 <= i <= n &&
@ (\forall integer j; 0 <= j < i ==> res <= t[j]) &&
@ (\exists integer j; 0 <= j < i && res == t[j]);
@ loop assigns i, res;
@ loop variant n - i;
@*/
for (int i = 1; i < n; i++)
{
if (t[i] < res)
res = t[i];
}
return res;
}
| 13 |
/*@ requires b != 0;
requires b != -1;
assigns \nothing;
ensures \result == a / b;
*/
int divide(int a, int b)
{
return a / b;
}
| 6 |
#include <limits.h>
/*@
requires (((x1>0) &&
\valid(x0+(0..x1-1))) &&
\valid(x2+(0..x1-1)));
ensures ((((0<=\result) &&
(\result<=x1)) &&
(\forall int x74; (((0<=x74) &&
(x74<\result)) ==> ((0<=x2[x74]) &&
(x2[x74]<x1))))) &&
(\forall int x86; (((0<x86) &&
(x86<\result)) ==> (x2[(x86-1)]<x2[x86]))));
assigns x2[(0..x1-1)];
*/
int index_where_even(int * x0, int x1, int * x2) {
int x5 = 0;
/*@
loop invariant ((((((0<=x6) &&
(x6<=x1)) &&
(0<=x5)) &&
(x5<=x6)) &&
(\forall int x28; (((0<=x28) &&
(x28<x5)) ==> ((0<=x2[x28]) &&
(x2[x28]<x6))))) &&
(\forall int x42; (((0<x42) &&
(x42<x5)) ==> (x2[(x42-1)]<x2[x42]))));
loop assigns x6, x5, x2[(0..x1-1)];
loop variant (x1-x6);
*/
for(int x6=0; x6 < x1; x6++) {
int x7 = x0[x6];
int x8 = x7 % 2;
int x9 = x8 == 0;
if (x9) {
int x10 = x5;
x2[x10] = x6;
x5 += 1;
} else {
}
}
int x62 = x5;
return x62;
}
| 15 |
#include <stdlib.h>
/*@
requires n >= 0 && n <= 100;
ensures \result >= 0;
ensures \result == (int)((n+1)*(n)/2);
assigns \nothing;
*/
int sum(char n) {
int s = 0;
char k = 0;
/*@
loop invariant 0 <= k <= n+1;
loop invariant s == (k-1)*(k)/2;
loop assigns k, s;
loop variant n - k;
*/
while(k <= n) {
s = s + (int)k;
k = k + 1;
}
return (int)s;
}
int main() {
int s = sum(5);
//@ assert s == 15;
}
| 19 |
#include<stdio.h>
/*@
requires \valid(a) && \valid(b) && \valid(c) ;
requires \separated(a, b, c);
assigns *a, *b, *c ;
ensures *a <= *b <= *c ;
ensures { *a, *b, *c } == \old({ *a, *b, *c }) ;
ensures \old(*a == *b == *c) ==> *a == *b == *c ;
ensures \old(*a == *b < *c || *a == *c < *b || *b == *c < *a) ==> *a == *b ;
ensures \old(*a == *b > *c || *a == *c > *b || *b == *c > *a) ==> *b == *c ;
*/
void order_3(int* a,int* b,int* c){
if(*a > *b){int tmp = *b ;*b = *a ;*a = tmp ; }
if(*a > *c){int tmp = *c ; *c = *a ;*a = tmp ; }
if(*b > *c){int tmp = *b ;*b = *c ;*c = tmp ;}
}
void test(){
int a1 =5, b1=3, c1=4;
order_3(&a1, &b1, &c1) ;
//@ assert a1 == 3 && b1 == 4 && c1 == 5 ;
int a2 =2, b2=2, c2=2;
order_3(&a2, &b2, &c2) ;
//@ assert a2 == 2 && b2 == 2 && c2 == 2 ;
int a3 =4, b3=3, c3=4;
order_3(&a3, &b3, &c3) ;
//@ assert a3 == 3 && b3 == 4 && c3 == 4 ;
int a4 =4, b4=5, c4=4;
order_3(&a4, &b4, &c4) ;
//@ assert a4 == 4 && b4 == 4 && c4 == 5 ;
}
| 45 |
// =================== Exercies 1 ===================
/*@
@ ensures \result >= a;
@ ensures \result >= b;
@ ensures \result >= c;
@ ensures \result == a || \result == b || \result == c;
@ assigns \nothing;
*/
int max3(int a, int b, int c) {
if (a >= b && a >= c) return a;
if (b >= b && b >= c) return b;
return c;
}
// =================== Exercies 2 ===================
/*@
@ requires 0 < n <= 100000000;
@ requires \valid(t+(0..n - 1));
@
@ ensures \forall int i; 0 <= i < n ==> t[i] == 2 * i;
*/
void double_(int t[], int n) {
/*@
@ loop invariant 0 <= i <= n;
@ loop invariant \forall int j; 0 <= j < i ==> t[j] == 2 * j;
@ loop variant n - i;
*/
for (int i = 0; i < n; ++i) {
t[i] = 2 * i;
}
}
// =================== Exercies 3 ===================
/*@
@ requires \valid(arr+(0.. n - 1));
@ requires n > 0;
@
@ assigns \nothing;
@ behavior true_:
@ assumes \forall int i; 1 <= i < n ==> arr[i] > arr[i - 1];
@ ensures \result == 1;
@ behavior false_:
@ assumes \exists int i; 1 <= i < n && arr[i] <= arr[i - 1];
@ ensures \result == 0;
*/
int increasing(int arr[], int n) {
/*@
@ loop invariant 1 <= i <= n;
@ loop invariant \forall int j; 1 <= j < i ==> arr[j] > arr[j - 1];
@ loop variant n - i;
*/
for (int i = 1; i < n; ++i) {
if (arr[i] <= arr[i - 1]) return 0;
}
return 1;
}
// =================== Exercies 4 ===================
/*@
@ requires \valid(arr+(0.. n - 1));
@ requires n > 0;
@
@ assigns \nothing;
@ behavior true_:
@ assumes \forall int i; 1 <= i < n ==> arr[i] < arr[i - 1];
@ ensures \result == 1;
@ behavior false_:
@ assumes \exists int i; 1 <= i < n && arr[i] >= arr[i - 1];
@ ensures \result == 0;
*/
int decreasing(int arr[], int n) {
/*@
@ loop invariant 1 <= i <= n;
@ loop invariant \forall int j; 1 <= j < i ==> arr[j] < arr[j - 1];
@ loop variant n - i;
*/
for (int i = 1; i < n; ++i) {
if (arr[i] >= arr[i - 1]) return 0;
}
return 1;
}
/*@
@ requires \valid(arr+(0.. n - 1));
@ requires n > 0;
@
@ assigns \nothing;
@ behavior increaing:
@ assumes \forall int i; 1 <= i < n ==> arr[i] > arr[i - 1];
@ ensures \result == 1;
@ behavior decreasing:
@ assumes \forall int i; 1 <= i < n ==> arr[i] < arr[i - 1];
@ ensures \result == -1;
@ behavior none:
@ assumes \exists int i; 1 <= i < n && arr[i] <= arr[i - 1];
@ assumes \exists int i; 1 <= i < n && arr[i] >= arr[i - 1];
@ ensures \result == 0;
*/
int monotomic(int arr[], int n) {
if (increasing(arr, n)) return 1;
if (decreasing(arr, n)) return -1;
return 0;
}
| 34 |
/*@ inductive is_gcd(integer a, integer b, integer d) {
case gcd_zero:
\forall integer n; is_gcd(n,0,n);
case gcd_succ:
\forall integer a,b,d; is_gcd(b, a % b, d) ==> is_gcd(a,b,d);
}
*/
/*@ axiomatic gcd {
logic integer gcd(integer a, integer b);
axiom nil:
\forall integer n; gcd(n,0) == n;
axiom next:
\forall integer a,b; gcd(b, a % b) == gcd(a,b);
}
*/
/*@
decreases b;
assigns \nothing;
ensures is_gcd(a, b, \result);
ensures \result == gcd(a, b);
*/
unsigned gcd_rec(unsigned a, unsigned b)
{
if (b == 0)
return a;
return gcd_rec(b, a % b);
}
| 11 |
#include <limits.h>
/*@ predicate inv_vec_Int(int * x0, integer x1) = ((x1==0) || ((x1>0) &&
\valid(x0+(0..x1-1))));*/
/*@ predicate eq_vec_Int(int * x15, int x16, int * x17, int x18) = ((x16==x18) &&
(\forall int x22; (0<=x22<x16) ==> (x15[x22]==x17[x22])));*/
/*@
requires (inv_vec_Int(x15,x16) &&
inv_vec_Int(x17,x18));
assigns \nothing;
ensures (inv_vec_Int(x15,x16) &&
inv_vec_Int(x17,x18));
ensures \result <==> eq_vec_Int(x15, x16, x17, x18);
*/
int eq_vec_Int(int * x15, int x16, int * x17, int x18) {
int x20 = x16 == x18;
int x31;
if (x20) {
int x30 = 1;
/*@ loop invariant (0 <= x23 <= x16);
loop invariant \forall int x22; (0 <= x22 < x23) ==> (x15[x22]==x17[x22]);
loop invariant x30==1;
loop assigns x23, x30;
loop variant (x16-x23); */
for (int x23 = 0; x23 < x16; x23++) {
int x27 = x15[x23];
int x28 = x17[x23];
int x29 = x27 == x28;
if (!x29) { x30 = 0; break; }
}
x31 = x30;
} else {
x31 = 0/*false*/;
}
return x31;
}
/*@ predicate inv_vec_vec_Int(int * * x35, int * x36, integer x37) = (((x37==0) || ((x37>0) &&
(\valid(x35+(0..x37-1)) &&
\valid(x36+(0..x37-1))))) &&
(\forall int x47; (0<=x47<x37) ==> inv_vec_Int(x35[x47],x36[x47])));*/
/*@ predicate eq_vec_vec_Int(int * * x58, int * x59, int x60, int * * x61, int * x62, int x63) = ((x60==x63) &&
(\forall int x67; (0<=x67<x60) ==> eq_vec_Int(x58[x67],x59[x67],x61[x67],x62[x67])));*/
/*@
requires (inv_vec_vec_Int(x58,x59,x60) &&
inv_vec_vec_Int(x61,x62,x63));
assigns \nothing;
ensures (inv_vec_vec_Int(x58,x59,x60) &&
inv_vec_vec_Int(x61,x62,x63));
ensures \result <==> eq_vec_vec_Int(x58, x59, x60, x61, x62, x63);
*/
int eq_vec_vec_Int(int * * x58, int * x59, int x60, int * * x61, int * x62, int x63) {
int x65 = x60 == x63;
int x80;
if (x65) {
int x79 = 1;
/*@ loop invariant (0 <= x68 <= x60);
loop invariant \forall int x67; (0 <= x67 < x68) ==> eq_vec_Int(x58[x67],x59[x67],x61[x67],x62[x67]);
loop invariant x79==1;
loop assigns x68, x79;
loop variant (x60-x68); */
for (int x68 = 0; x68 < x60; x68++) {
int *x74 = x58[x68];
int x75 = x59[x68];
int *x76 = x61[x68];
int x77 = x62[x68];
int x78 = eq_vec_Int(x74,x75,x76,x77);
if (!x78) { x79 = 0; break; }
}
x80 = x79;
} else {
x80 = 0/*false*/;
}
return x80;
}
| 48 |
/*@ assigns \nothing;
ensures \result == a / 2;
*/
unsigned rshift(unsigned a)
{
return a >> 1;
}
| 4 |
#include <stdint.h>
#include <stddef.h>
#define NUM_ELEMS (8)
/*@ requires expected != test;
@ requires \let n = NUM_ELEMS;
@ \valid_read(expected + (0.. n-1)) && \valid_read(test + (0.. n-1));
@ assigns \nothing;
@ behavior matches:
@ assumes \let n = NUM_ELEMS;
@ \forall integer i; 0 <= i < n ==> expected[i] == test[i];
@ ensures \result == 1;
@ behavior not_matches:
@ assumes \let n = NUM_ELEMS;
@ \exists integer i; 0 <= i < n && expected[i] != test[i];
@ ensures \result == 0;
@ complete behaviors;
@ disjoint behaviors;
@*/
int array_equals(const uint32_t expected[static NUM_ELEMS], const uint32_t test[static NUM_ELEMS]) {
/*@ loop invariant \let n = NUM_ELEMS; 0 <= i <= n;
@ loop invariant \forall integer k; 0 <= k < i ==> expected[k] == test[k];
@ loop assigns i;
@ loop variant \let n = NUM_ELEMS; n-i;
@*/
for (size_t i = 0; i < NUM_ELEMS; i++) {
if (expected[i] != test[i]) {
return 0;
}
}
return 1;
}
| 18 |
// Program to find index of an element in an array
// Behaviors not used in this program
/*@
requires n >= 0;
requires \valid_read(arr+(0..n-1));
assigns \nothing;
ensures -1 <= \result < n;
ensures 0 <= \result < n ==> arr[\result] == x;
ensures (\result == -1) ==> (\forall integer i; 0 <= i < n ==> arr[i] != x);
assigns \nothing;
*/
int array_find(int* arr, int n, int x) {
int i = 0;
/*@
loop invariant 0 <= i <= n;
loop invariant \forall integer k; 0 <= k < i ==> arr[k] != x;
loop assigns i;
loop variant n-i;
*/
for (i = 0; i < n; i++) {
if (arr[i] == x) {
return i;
}
}
return -1;
}
// from this directory run: frama-c-gui -wp array_find.c
| 18 |
#include <limits.h>
/*@
requires ((x1>0) &&
\valid(x0+(0..x1-1)));
assigns \nothing;
ensures (((\result==-1) ==> (!(\exists int x56; (((0<=x56) &&
(x56<x1)) &&
(x0[x56]==x2))))) &&
((\result!=-1) ==> (((0<=\result) &&
(\result<x1)) &&
(x0[\result]==x2))));
*/
int member(int * x0, int x1, int x2) {
int x4 = -1;
/*@
loop invariant ((((0<=x6) &&
(x6<=x1)) &&
((x4==-1) ==> (!(\exists int x22; (((0<=x22) &&
(x22<x6)) &&
(x0[x22]==x2)))))) &&
((x4!=-1) ==> (((0<=x4) &&
(x4<x6)) &&
(x0[x4]==x2))));
loop assigns x6, x4;
loop variant (x1-x6);
*/
for(int x6=0; x6 < x1; x6++) {
int x7 = x4;
int x8 = x7 == -1;
int x11;
if (x8) {
int x9 = x0[x6];
int x10 = x9 == x2;
x11 = x10;
} else {
x11 = 0/*false*/;
}
if (x11) {
x4 = x6;
} else {
}
}
int x50 = x4;
return x50;
}
| 13 |
#include <limits.h>
/*@ predicate inv_vec_Int(int * x0, int x1) = ((x1==0) || ((x1>0) &&
\valid(x0+(0..x1-1))));*/
/*@ predicate eq_vec_Int(int * x16, int x17, int * x18, int x19) = ((x17==x19) &&
(\forall int x23; (0<=x23<x17) ==> (x16[x23]==x18[x23])));*/
/*@
requires (inv_vec_Int(x16,x17) &&
inv_vec_Int(x18,x19));
assigns \nothing;
ensures (inv_vec_Int(x16,x17) &&
inv_vec_Int(x18,x19));
ensures \result <==> eq_vec_Int(x16, x17, x18, x19);
*/
int eq_vec_Int(int * x16, int x17, int * x18, int x19) {
int x21 = x17 == x19;
int x33;
if (x21) {
int x32 = 1;
/*@ loop invariant (0 <= x24 <= x17);
loop invariant \forall int x23; (0 <= x23 < x24) ==> (x16[x23]==x18[x23]);
loop assigns x24;
loop variant (x17-x24); */
for (int x24 = 0; x24 < x17; x24++) {
int x29 = x16[x24];
int x30 = x18[x24];
int x31 = x29 == x30;
if (!x31) { x32 = 0; break; }
}
x33 = x32;
} else {
x33 = 0/*false*/;
}
return x33;
}
| 18 |
/*@ predicate swapped{L1,L2}(int *a, int *b) =
\at(*a, L2) == \at(*b,L1) &&
\at(*b, L2) == \at(*a,L1);
*/
/*@ requires \valid(a);
requires \valid(b);
assigns *a, *b;
ensures swapped{Pre, Post}(a, b);
*/
void swap(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}
| 9 |
typedef enum{
VRAI=1,
FALSE=0
}T_BOOLEEN;
/*@logic T_BOOLEEN test (integer b)=
@
@ ((b==1)?
@ (T_BOOLEEN)VRAI
@ : (T_BOOLEEN)FALSE);
@*/
/*@ensures \result == test(boo);
@*/
T_BOOLEEN test(int boo)
{
T_BOOLEEN b;
if (boo==1)
b = VRAI;
else
b= FALSE;
return b;
}
| 3 |
/*
* Nikos Mavrogeorgis 03113087
* Frama-C version : Sulfur-20171101
*/
#include <stdbool.h>
#define MAXV 1000000
/*@
@ requires 1 <= N;
@ requires \valid (a + (0 .. N - 1));
@ requires \forall integer i; 0 <= i < N ==> 1 <= a[i] <= MAXV;
@ ensures \result != 0 <==> \exists integer i, j; 0 <= i < j < N && a[i] == a[j] == \result;
@*/
int findDouble(int N, int a[]) {
bool f[MAXV];
/*@
@ loop invariant \let n = MAXV; 1 <= i <= n + 1;
@ loop invariant \forall integer k; 1 <= k < i ==> f[k-1] == false;
@ loop assigns i, f[0 .. (i - 1)];
@ loop variant \let n = MAXV; n-i;
@*/
for (int i = 1; i <= MAXV; ++i) f[i-1] = false;
/*@
@ loop invariant 0 <= i <= N;
@ loop invariant \let n = MAXV; \forall integer k; 1 <= k <= n ==>
@ (f[k-1] <==> \exists integer j; 0 <= j < i && a[j] == k);
@ loop assigns i;
@ loop assigns f[..];
@ loop variant N - i;
@*/
for (int i = 0; i < N; i++) if (f[a[i]-1]) return a[i]; else f[a[i]-1] = true;
return 0;
}
| 34 |
/*@
requires a >= -2147483648 && a <= 2147483647;
requires b >= -2147483648 && b <= 2147483647;
ensures \result == a;
*/
int trans(int a, int b){
int c = a;
b = c;
return b;
}
| 3 |
#include<stdio.h>
struct scorecard{
int total_runs;
int wickets;
int total_overs;
int over_complete;
int target_score;
};
/*@
requires 0<=runs<1000 && 0<=wic<=10 && 0<=comp<=20;
ensures a->total_runs==\old(a->total_runs)+runs;
ensures a->wickets==\old(a->wickets)+wic;
ensures a->over_complete==\old(a->over_complete)+comp;
*/
void update_scorecard(struct scorecard *a,int runs, int wic,int comp){
a->total_runs+=runs;
a->wickets+=wic;
a->over_complete+=comp;
}
| 3 |
/* run.config_qualif
DONTRUN: [PB] temporary removed since a difference has to be validated.
*/
/* run.config_qualif
OPT: -wp-par 1 -load-script tests/wp_plugin/combined.ml
*/
/* ZD : this should not be here such as it cannot be tested by all frama-c
developer
*/
/*@ axiomatic A {
@ predicate P(int x);
@ }*/
/*@ ensures P(\result);
@ assigns \nothing; */
int f(int i);
/*@ assigns \nothing; */
int g(int j);
void job(int *t, int A) {
/*@ assert 50 <= A <= 100; */
/*@ loop invariant 0 <= i <= 50;
@ loop invariant \forall integer k; 0 <= k < i ==> P(t[k]);
@ loop assigns i,t[0..49];
@ */
for(int i = 0; i < 50; i++) t[i] = f(i);
/*@ loop invariant A <= j <= 100;
@ loop assigns j,t[A..99];
@ */
for(int j = A; j < 100; j++) t[j] = g(j);
/*@ assert \forall integer k; 0 <= k < 50 ==> P(t[k]); */
}
int T[100];
void main(void) {
job(T, 50);
// job(T, 48);
}
| 3 |
/*@
requires \valid(p);
requires \valid(q);
assigns *p;
assigns *q;
ensures *p == \old(*q);
ensures *q == \old(*p);
*/
void swap(int* p, int* q){
int tmp = *p;
*p=*q;
*q=tmp;
return;
}
| 10 |
/*@
@ requires 0 <= n <= 1000;
@ ensures 2 * \result == n * (n + 1);
@ assigns \nothing;
*/
int sum_n(int n) {
int res = 0;
/*@
@ loop invariant 0 <= i <= n + 1;
@ loop invariant 2 * res == i * (i - 1);
@ loop variant n - i + 1;
*/
for (int i = 0; i <= n; ++i) {
res += i;
}
return res;
}
| 10 |
typedef struct vector
{
int* addr;
unsigned int sz;
unsigned int cap;
} vector;
/*@
predicate invariant{L}(vector* v) =
v->sz <= v->cap &&
\valid(v->addr + (0..v->cap-1)) &&
\separated(v, v->addr + (0..v->cap-1));
predicate full{L}(vector* v) = (v->sz == v->cap);
*/
/*@
requires \valid(v);
requires invariant(v);
assigns v->sz;
assigns v->addr[v->sz];
behavior enough_space:
assumes !full{Pre}(v);
assigns v->sz;
assigns v->addr[v->sz];
ensures \result == 1;
ensures v->sz == \old(v->sz) + 1;
ensures v->addr[\old(v->sz)] == x;
ensures \forall integer i; 0 <= i < \old(v->sz) ==> v->addr[i] == \old(v->addr[i]);
behavior no_space:
assumes full{Pre}(v);
assigns \nothing;
ensures \result == 0;
complete behaviors;
disjoint behaviors;
*/
int push_back(vector* v, int x)
{
if (v->sz < v->cap)
{
v->addr[v->sz] = x;
v->sz++;
return 1;
}
else
{
return 0;
}
}
/*@
requires \valid(v);
requires invariant(v);
requires v->sz + 1 < v->cap;
assigns v->sz;
assigns v->addr[v->sz];
assigns v->addr[v->sz + 1];
ensures v->sz == \old(v->sz) + 2;
ensures v->addr[\old(v->sz)] == x;
ensures v->addr[\old(v->sz) + 1] == x;
ensures \forall integer i; 0 <= i < \old(v->sz) ==> v->addr[i] == \old(v->addr[i]);
*/
void push_back_twice(vector* v, int x)
{
push_back(v, x);
//@ assert !full(v);
push_back(v, x);
}
| 43 |
//find the max element of array
/*@
requires n>0;
requires \valid_read(arr+(0..n-1));
ensures \forall integer res;
0<=res<n ==> \result >= arr[res];
*/
int checkPrime(int arr[], int n)
{
int max = arr[0];
/*@
loop invariant \forall integer k;
0<=k<i ==> max>=arr[k];
loop invariant 1<=i<=n;
loop assigns i, max;
loop variant n-i;
*/
for (int i = 1; i < n; i++)
{
if (max < arr[i])
{
max = arr[i];
}
}
return max;
}
| 14 |
/*@ requires \valid(a);
requires \valid(b);
assigns *a;
assigns *b;
ensures *a == \old(*b);
ensures *b == \old(*a);
*/
void swap(int *a, int *b);
/*@ requires \valid(a);
requires \valid(b);
assigns *a, *b;
ensures *a <= *b;
behavior ret:
assumes *a <= *b;
ensures *a == \old(*a);
ensures *b == \old(*b);
behavior swap:
assumes *a > *b;
ensures *a == \old(*b);
ensures *b == \old(*a);
complete behaviors;
disjoint behaviors;
*/
void max_ptr(int *a, int *b)
{
if (*a <= *b) {
return;
} else {
swap(a, b);
}
}
| 15 |
typedef int assert;
assert behavior = 0;
/*@ logic assert foo(assert x) = x; */
/*@ requires behavior >= 0;
assigns behavior \from behavior;
ensures behavior >= 0;
*/
int main () {
behavior++;
return 0;
}
/*@ type List<A> = Nil | Cons(A,List<A>); */
/*@ inductive model{L}(List<integer> root, List<integer>logic_list) {
case nil{L}: model(Nil,Nil);
case cons{L}: \forall List<integer> l1,List<integer>ll1;
model{L}(l1,ll1) ==> model(Cons(0,l1),Cons(0,ll1));
} */
| 7 |
#include <limits.h>
/*@
requires ((((((((0<x0) &&
(x0<100)) &&
(0<x1)) &&
(x1<100)) &&
(0<=x2)) &&
(0<=x3)) &&
(x2<x0)) &&
(x3<x1));
assigns \nothing;
ensures ((0<=\result) &&
(\result<(x0*x1)));
*/
int index(int x0, int x1, int x2, int x3) {
int x5 = x2 * x1;
int x6 = x5 + x3;
return x6;
}
/*@ predicate inv_matrix_Boolean(int * x36, int x37, int x38) = (((((x37<100) &&
(x38<100)) &&
(0<x37)) &&
(0<x38)) &&
(((x37*x38)>0) &&
\valid(x36+(0..(x37*x38)-1))));*/
/*@
requires (((inv_matrix_Boolean(x79,x80,x81) &&
inv_matrix_Boolean(x82,x83,x84)) &&
inv_matrix_Boolean(x85,x86,x87)) &&
(((x81==x83) &&
(x80==x86)) &&
(x84==x87)));
ensures ((inv_matrix_Boolean(x79,x80,x81) &&
inv_matrix_Boolean(x82,x83,x84)) &&
inv_matrix_Boolean(x85,x86,x87));
*/
void mult(int * x79, int x80, int x81, int * x82, int x83, int x84, int * x85, int x86, int x87) {
/*@
loop invariant 0<=x92<=x80;
loop assigns x92, x85[(0..(x86*x87)-1)];
loop variant x80-x92;
*/
for(int x92=0; x92 < x80; x92++) {
/*@
loop invariant 0<=x94<=x84;
loop assigns x94, x85[(0..(x86*x87)-1)];
loop variant x84-x94;
*/
for(int x94=0; x94 < x84; x94++) {
int x95 = index(x86,x87,x92,x94);
x85[x95] = 0/*false*/;
/*@
loop invariant 0<=x98<=x81;
loop assigns x98, x85[(0..(x86*x87)-1)];
loop variant x81-x98;
*/
for(int x98=0; x98 < x81; x98++) {
int x99 = x85[x95];
int x100 = index(x80,x81,x92,x98);
int x101 = x79[x100];
int x104;
if (x101) {
int x102 = index(x83,x84,x98,x94);
int x103 = x82[x102];
x104 = x103;
} else {
x104 = 0/*false*/;
}
int x105 = x99 || x104;
x85[x95] = x105;
}
}
}
}
| 52 |
# pragma SeparationPolicy(none)
/*@
requires \valid(p);
requires \valid(q);
assigns *p;
assigns *q;
ensures *p == \old(*q);
ensures *q == \old(*p);
*/
void swap(int* p, int* q)
{
int const save = *p;
*p = *q;
*q = save;
}
int main () {
int p[2] = { 0,1};
int *q = (int *)((char*)q+1);
swap(p,q);
}
| 52 |
#include <limits.h>
#include <string.h>
/*@
requires ((strlen(x0)>=0) &&
\valid(x0+(0..strlen(x0))));
assigns \nothing;
ensures ((\result==-1) || ((0<=\result) &&
(\result<=9)));
*/
int p(char * x0) {
int x8 = -1;
int x9 = 1/*true*/;
char x10 = '\0';
char *x11 = 0/*null*/;
char x2 = x0[0];
int x3 = x2 == '\0';
if (x3) {
x11 = x0;
} else {
int x4 = x2 >= '0';
int x6;
if (x4) {
int x5 = x2 <= '9';
x6 = x5;
} else {
x6 = 0/*false*/;
}
if (x6) {
x9 = 0/*false*/;
x10 = x2;
char *x7 = x0+1;
x11 = x7;
} else {
x11 = x0;
}
}
int x23 = x9;
if (x23) {
char *x24 = x11;
} else {
char x26 = x10;
char *x28 = x11;
char x27 = x26 - '0';
x8 = x27;
}
int x32 = x8;
return x32;
}
| 13 |
/* ****************************************************************************
MATRICE SYMÉTRIQUE
L'énoncé est introduit sous la forme de commentaires C. Les différents
morceaux de programme et de spécification à considérer sont mentionnés en
programmation littéraire :
https://en.wikipedia.org/wiki/Literate_programming
************************************************************************* */
/* ---------------------------------------------------------------------------
Petits rappels de mathématiques élémentaires à toutes fins utiles :
- Une matrice carrée de taille N (N, entier naturel) est une matrice
possédant N lignes et N colonnes.
- Une matrice carrée A est dite symétrique si et seulement si A_{ij} =
A_{ji} pour toute ligne [i] et colonne [j].
------------------------------------------------------------------------- */
#include <stdbool.h>
/* ---------------------------------------------------------------------------
La fonction [is_symmetric] ci-dessous retourne [true] si et seulement si
[matrix] est une matrice symétrique de taille [len]. Elle retourne [false]
sinon.
Question 1 : spécifier cette fonction en utilisant des comportements ACSL.
Question 2 : prouver cette fonction, y compris sa terminaison et l'absence
d'erreurs à l'exécution.
------------------------------------------------------------------------- */
/*@ requires \valid(matrix[0..len-1]+(0..len-1));
@ requires \valid(matrix+(0..len-1));
@ requires len >= 0;
@ assigns \nothing;
@ behavior symm:
@ assumes \forall integer i,j; 0 <= i < len ==> 0 <= j < len ==> matrix[i][j] == matrix[j][i];
@ ensures \result == true;
@ behavior nosymm:
@ assumes \exists integer i,j; 0 <= i < len && 0 <= j < len && matrix[i][j] != matrix[j][i];
@ ensures \result == false;
@ complete behaviors;
@ disjoint behaviors;
@ */
_Bool is_symmetric(int **matrix, int len) {
/*@loop invariant 0 <= i <= len;
@loop invariant \forall integer k, l; 0 <= k < i ==> 0 <= l < k ==> matrix[k][l] == matrix[l][k];
@loop assigns i;
@loop variant len - i;
@ */
for (int i = 0; i < len; i++)
/*@loop invariant 0 <= j <= i;
@loop invariant \forall integer k; 0 <= k < j ==> matrix[i][k] == matrix[k][i];
@loop assigns j;
@loop variant i - j;
@ */
for (int j = 0; j < i; j++)
if (matrix[i][j] != matrix[j][i])
return false;
return true;
}
| 31 |
/*@ assigns \nothing;
ensures \result == \max(a, b) - \min(a, b);
*/
unsigned distance(unsigned a, unsigned b)
{
return (a > b) ? (a - b) : (b - a);
}
| 5 |
#include <stdbool.h>
/*@ requires N > 0;
@ requires \valid(a+(0..N-1));
@ requires \forall integer i;
@ 0 <= i < N ==> -1000000000 <= a[i] <= 1000000000;
@ ensures \result <==> (\exists integer i, j;
@ 0 <= i < j < N && a[i] + a[j] == X);
@*/
bool sumx (int N, int a[], int X)
{
int i, j;
/*@ loop invariant 0 <= i < N;
@ loop invariant \forall integer ii, jj;
@ 0 <= ii < jj < N && ii < i ==> a[ii] + a[jj] != X;
@ loop assigns i, j;
@ loop variant N-i-2;
@*/
for (i=0; i<N-1; i++)
/*@ loop invariant i+1 <= j <= N;
@ loop invariant \forall integer ii, jj;
@ 0 <= ii < jj < N && ii < i ==> a[ii] + a[jj] != X;
@ loop invariant \forall integer jj;
@ 0 <= i < jj < j ==> a[i] + a[jj] != X;
@ loop assigns j;
@ loop variant N-j;
@*/
for (j=i+1; j<N; j++)
if (a[i] + a[j] == X)
return true;
return false;
}
| 27 |
/*@
requires 0 <= N <= 1000000000;
assigns \nothing;
ensures \result * \result <= N ;
ensures N < (\result+1) * (\result+1);
*/
int root(int N){
int R = 0;
/*@
loop invariant 0 <= R * R <= N;
loop assigns R;
loop variant N-R;
*/
while(((R+1)*(R+1)) <= N) {
R = R + 1;
}
return R;
}
| 15 |
#include <string.h>
/*@
requires strlen(a)>=0 && \valid(a+(0..strlen(a)));
assigns \nothing;
ensures 0<=\result || \result==-1;
*/
int my_atoi(char* a) {
int m = INT_MAX/10 - 10;
int r = 0;
char* s = a;
/*@
loop invariant strlen(s)>=0 && \valid(s+(0..strlen(s)));
loop invariant 0 <= r;
loop assigns r, s;
loop variant strlen(s);
*/
while ('0' <= *s && *s <= '9') {
if (r > m) return -1;
r = 10*r + (*s - '0');
s++;
}
return r;
}
| 21 |
/*@ logic integer \fact(integer n) = (n <= 0) ? 1 : n * \fact(n-1);
*/
/*@ requires n >= 0 && n <= 10;
ensures \result == \fact(n);
assigns \nothing;
*/
int factorial(int n)
{
int i = 1;
int f = 1;
/*@
loop invariant 1 <= i <= n+1;
loop invariant f == \fact(i-1);
loop assigns f, i;
loop variant n-i+1;
*/
while (i<=n) {
f = f * i;
i = i + 1;
}
return f;
}
/*@ assigns \nothing; */
int main(void) {
int n = 5;
int ret = factorial(n);
return 0;
}
| 21 |
typedef struct _singly_list {
int elt;
struct _singly_list* next;
} singly_list_t;
/*@
@ type list<A> = Nul | Cons(A, list<A>);
@
@
*/
/*@
@ inductive wf_singly_list{L}(singly_list_t* lst){
@ case empty: \forall singly_list_t* lst; lst == \null ==> wf_singly_list(lst);
@ case non_empty: \forall singly_list_t* lst; lst != \null ==> \valid(lst) ==> wf_singly_list(lst->next) ==> wf_singly_list(lst);
@ }
@
@ axiomatic wf_singly_list {
@ axiom wf_singly_list_inversion: \forall singly_list_t* lst; wf_singly_list(lst) ==>
@ lst == \null ||
@ (lst != \null && \valid(lst) && wf_singly_list(lst->next));
@ }
@
@
*/
/*@
@ inductive singly_list_length{L}(singly_list_t* lst, integer sz){
@ case empty: \forall singly_list_t* lst; lst == \null ==> singly_list_length(lst, 0);
@ case non_empty: \forall singly_list_t* lst; \forall integer sz; lst != \null ==> \valid(lst) ==> singly_list_length(lst->next, sz) ==> singly_list_length(lst, sz+1);
@ }
@
@ axiomatic singly_list_length {
@ axiom singly_list_length_inversion: \forall singly_list_t* lst; \forall integer sz; singly_list_length(lst, sz) ==>
@ (lst == \null && sz == 0) ||
@ (\exists integer sz2; lst != \null && \valid(lst) && singly_list_length(lst->next, sz2) && sz == sz2+1);
@ }
@
*/
/*@
@ inductive reachable{L}(singly_list_t *lst1, singly_list_t *lst2, integer n){
@ case reachable1: \forall singly_list_t *lst; reachable(lst, lst, 0);
@ case reachable2: \forall singly_list_t *lst1, *lst2; \forall integer n1, n2; lst1 != \null ==> \valid(lst1) ==> n2 == n1 + 1 ==> reachable(lst1->next, lst2, n1) ==> reachable(lst1, lst2, n2);
@ }
@
@
@
*/
/*@
@ axiomatic reachable {
@ axiom reachable_inversion: \forall singly_list_t *lst1, *lst2; \forall integer n; reachable(lst1, lst2, n) ==>
@ (lst1 == lst2 && n == 0) || (n > 0 && lst1 != \null && \valid(lst1) && reachable(lst1->next, lst2, n - 1));
@ axiom reachable_trans: \forall singly_list_t *lst1, *lst2, *lst3; \forall integer n1, n2, n3; n3 == n1 + n2 ==> reachable(lst1, lst2, n1) ==> reachable(lst2, lst3, n2) ==> reachable(lst1, lst3, n3);
@ // fora now as axioms ...
@ // axiom reachable_lhs_next: \forall singly_list_t *lst; lst != \null && \valid(lst) ==> reachable(lst, lst->next, 1);
@ axiom reachable_rhs_next: \forall singly_list_t *lst1, *lst2; \forall integer n; reachable(lst1, lst2, n) && lst2 != \null && \valid(lst2) ==> reachable(lst1, lst2->next, n + 1);
@ }
@
@
@
@ predicate circular_singly_list{L}(singly_list_t *lst) = \exists singly_list_t* lst2; \exists integer n;
@ reachable(lst, lst2, n) && (\exists integer m; m >0 && reachable (lst2, lst2, m));
@
@ axiomatic circular_singly_list {
@ // this should be a lemma ...
@ axiom null_reachable_non_circular: \forall singly_list_t *lst; \forall integer n; reachable(lst, \null, n) ==> !circular_singly_list(lst);
@ }
@
@
*/
/*@ // algorithm for detecting circular list
@ requires wf_singly_list(lst);
@ ensures wf_singly_list(lst);
@ assigns \nothing;
@ ensures \result == 0;
@*/
int is_circular_singly_list(singly_list_t* lst) {
return 0;
}
| 5 |
/* Generated by Frama-C */
int global_i;
int *global_i_ptr = & global_i;
int global_i = 0;
/*@ assigns \nothing; */
void loop(void)
{
return;
}
/*@ assigns \nothing; */
void __gen_e_acsl_loop(void)
{
loop();
return;
}
/*@ assigns global_i, global_i_ptr; */
int main(void)
{
int __retres;
/* Initialize global variables */
global_i = 0;
global_i_ptr = &global_i;
__gen_e_acsl_loop();
__retres = 0;
return __retres;
}
| 12 |
#include<limits.h>
/*@ requires x >= 1;
requires y >= 1;
requires z>= 1;
requires x<=INT_MAX && y<=INT_MAX && z<=INT_MAX;
requires x+y<=INT_MAX && y+z<=INT_MAX && z+x<=INT_MAX;
ensures (x+y <= z || y+z <=x || x+z <=y) ==> \result == 0;
ensures x+y > z && y+z >x && x+z >y && x == y && y == z ==> \result==1;
ensures x+y > z && y+z >x && x+z >y && (x != y || y != z) ==> \result==0;
assigns \nothing;
*/
int triangle(int x,int y,int z)
{
if(x+y > z && y+z >x && x+z >y)
{
if(x == y && y == z){
return 1;
}
else if(x == y || y == z || x==z){
return 0;
}
else if((x!=y)&&(y!=z)&&(z!=x)) {
return 0;
}
}
return 0;
}
int main()
{
int t = triangle(4,4,4);
return 0;
}
| 22 |
/*@ axiomatic ellipsoids_proof_tactics {
@ type ellipsoids_tactics = Intuition | Tactic2;
@ predicate use_strategy (ellipsoids_tactics t);
@ }
*/
/*@ requires x < 0 && x > -1073741824;
@ ensures \result == 2 * (x + 1);
@ assigns \nothing;
*/
int plus_one (int x) {
int y,z;
{
/*@ assert x + 1 <= 1073741823; */
y = x + 1;
}
{
/*@ assert 2 * y <= 2147483647; */
z = 2 * y;
}
return z;
}
| 10 |
/*@
@ requires n > 0;
@ requires \valid_read(a+(0..n - 1));
@ requires \valid_read(b+(0..n - 1));
@ requires \valid(c+(0..n - 1));
@ requires \separated(a+(0..n-1), b+(0..n-1), c+(0..n-1));
@ requires \forall integer i; 0 <= i < n ==> -10000 <= a[i] <= 10000;
@ requires \forall integer i; 0 <= i < n ==> -10000 <= b[i] <= 10000;
@ ensures \forall integer i; 0 <= i < n ==> c[i] == a[i] + b[i];
@ assigns c[0..n-1];
*/
void sum_array(int a[], int b[], int c[], int n) {
/*@
@ loop invariant 0 <= i <= n;
@ loop invariant \valid_read(a+(0..n - 1));
@ loop invariant \valid_read(b+(0..n - 1));
@ loop invariant \valid(c+(0..n - 1));
@ loop invariant \forall integer j; 0 <= j < i ==> c[j] == a[j] + b[j];
@ loop assigns i, c[0..n-1];
@ loop variant n - i;
*/
for (int i = 0; i < n; ++i) {
c[i] = a[i] + b[i];
}
}
| 25 |
/*@
requires \valid_read(p);
ensures \result == *p;
*/
int foo(int* p) {
return *p;
}
| 4 |
/*@
requires \valid_read(p) && \valid_read(q);
requires -10000000<*p<10000000 && -10000000<*q<10000000;
ensures \result==*p+*q;
assigns \nothing;
*/
int add(int*p,int*q){
return*p + *q ;
}
/*@ assigns \nothing; */
int main(){
int a =24,b =42,x ;
x = add(&a, &b) ;
x = add(&a, &a) ;
}
| 20 |
/*@ predicate valid_subseq{L}(int *x, integer left, integer right) =
@ left < right ==> \forall integer i, j; left <= i < right && left <= j < right ==> x[i] == x[j];
*/
/*@ requires 1 <= N <= 1000000;
@ requires \valid(x + (0..N-1));
@ ensures 1 <= \result <= N;
@ ensures \exists integer k; 0 <= k < N && valid_subseq(x, k, k + \result);
@ assigns \nothing;
*/
int countSameConsecutive(int N, int x[]) {
int best = 0, i = 0;
/*@ loop invariant 0 <= i <= N;
@ loop invariant i == 0 ==> best == 0;
@ loop invariant i > 0 ==> 1 <= best <= i;
@ loop invariant i > 0 ==> \exists integer k; 0 <= k < i && valid_subseq(x, k, k + best);
@ loop assigns i, best;
@ loop variant N - i;
*/
while (i < N) {
int j = i+1;
/*@ loop invariant i < j <= N;
@ loop invariant valid_subseq(x, i, j);
@ loop assigns j;
@ loop variant N - j;
*/
while (j < N && x[j] == x[i]) ++j;
/*@ assert (j < N ==> (x[j] != x[i] && x[j] != x[j - 1])) || j == N;*/
/*@ assert i == 0 && j == N ==> valid_subseq(x, 0, N);*/
if (j-i > best) best = j-i;
/*@ assert j - i <= best;*/
i = j;
}
/*@ assert best <= N;*/
return best;
}
| 36 |
/*@
requires \valid(t+(0..n-1)) && n>0;
ensures (\forall integer i; 0<=i<n ==> t[i] == 0) ==> \result == 1;
ensures (\exists integer i; 0<=i<n && t[i] != 0) ==> \result == 0;
*/
int all_zeros(int t[], int n){
/*@
loop invariant 0<=i<=n;
loop invariant \forall integer j; 0 <= j < i ==> t[j] == 0;
loop assigns i;
loop variant n-i;
*/
for(int i=0;i<n;i++){
if(t[i] != 0)
return 0;
}
return 1;
}
| 13 |
/*@
requires x >= 0;
ensures \result == x;
assigns \nothing;
*/
int foo(int x) {
return x;
}
| 4 |
/*@ requires n <= 2147483646;
ensures \result == \old(n) + 1 ;
assigns \nothing; */
int incr(int n)
{
return n+1;
};
| 5 |
//@ predicate null(char *x) = x == 0;
//@ predicate eq(char *x, char *y) = x == y;
//@predicate my_null(char *x) = x == (void*)0;
void f(char *x) {
x = 0;
//@ assert x == (void*)0;
//@ assert my_null(x);
//@ assert null(x);
//@ assert eq(x,0);
}
//@ ensures \result == \true;
int g() { return 1; }
/*@ predicate foo (integer x) = x != 0; */
/*@ ensures foo(1); */
int h() { return 1; }
| 12 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.