code stringlengths 129 20.6k | ground_truth stringlengths 148 21.8k | file_name stringlengths 15 119 | id int64 1 497 |
|---|---|---|---|
function sorted(a: array<int>) : bool
reads a
{
forall i,j : int :: 0 <= i < j < a.Length ==> a[i] <= a[j]
}
method BinarySearch(a: array<int>, x: int) returns (index: int)
requires sorted(a)
ensures 0 <= index < a.Length ==> a[index] == x
ensures index == -1 ==> forall i : int :: 0 <= i < a.Length ==> a[i] != x
{
var low := 0;
var high := a.Length - 1;
var mid := 0;
while (low <= high)
{
mid := (high + low) / 2;
if a[mid] < x {
low := mid + 1;
}
else if a[mid] > x {
high := mid - 1;
}
else {
return mid;
}
}
return -1;
}
|
function sorted(a: array<int>) : bool
reads a
{
forall i,j : int :: 0 <= i < j < a.Length ==> a[i] <= a[j]
}
method BinarySearch(a: array<int>, x: int) returns (index: int)
requires sorted(a)
ensures 0 <= index < a.Length ==> a[index] == x
ensures index == -1 ==> forall i : int :: 0 <= i < a.Length ==> a[i] != x
{
var low := 0;
var high := a.Length - 1;
var mid := 0;
while (low <= high)
invariant 0 <= low <= high + 1 <= a.Length
invariant x !in a[..low] && x !in a[high + 1..]
{
mid := (high + low) / 2;
if a[mid] < x {
low := mid + 1;
}
else if a[mid] > x {
high := mid - 1;
}
else {
return mid;
}
}
return -1;
}
| 630-dafny_tmp_tmpz2kokaiq_Solution.dfy | 1 |
// Noa Leron 207131871
// Tsuri Farhana 315016907
predicate Sorted(q: seq<int>) {
forall i,j :: 0 <= i <= j < |q| ==> q[i] <= q[j]
}
/*
Goal: Implement the well known merge sort algorithm in O(a.Length X log_2(a.Length)) time, recursively.
- Divide the contents of the original array into two local arrays
- After sorting the local arrays (recursively), merge the contents of the two returned arrays using the Merge method (see below)
- DO NOT modify the specification or any other part of the method's signature
- DO NOT introduce any further methods
*/
method MergeSort(a: array<int>) returns (b: array<int>)
ensures b.Length == a.Length && Sorted(b[..]) && multiset(a[..]) == multiset(b[..])
{
if (a.Length <= 1) {b := a;}
else{
var mid: nat := a.Length / 2;
var a1: array<int> := new int[mid];
var a2: array<int> := new int[a.Length - mid];
var i: nat := 0;
while (i < a1.Length )
{
a1[i] := a[i];
a2[i] := a[i+mid];
i:=i+1;
}
if(a1.Length < a2.Length) {
a2[i] := a[i+mid];
} // If a.Length is odd.
else{
}
a1:= MergeSort(a1);
a2:= MergeSort(a2);
b := new int [a.Length];
Merge(b, a1, a2);
}
}
ghost predicate Inv(a: seq<int>, a1: seq<int>, a2: seq<int>, i: nat, mid: nat){
(i <= |a1|) && (i <= |a2|) && (i+mid <= |a|) &&
(a1[..i] == a[..i]) && (a2[..i] == a[mid..(i+mid)])
}
/*
Goal: Implement iteratively, correctly, efficiently, clearly
DO NOT modify the specification or any other part of the method's signature
*/
method Merge(b: array<int>, c: array<int>, d: array<int>)
requires b != c && b != d && b.Length == c.Length + d.Length
requires Sorted(c[..]) && Sorted(d[..])
ensures Sorted(b[..]) && multiset(b[..]) == multiset(c[..])+multiset(d[..])
modifies b
{
var i: nat, j: nat := 0, 0;
while i + j < b.Length
{
i,j := MergeLoop (b,c,d,i,j);
}
LemmaMultysetsEquals(b[..],c[..],d[..],i,j);
}
//This is a method that replace the loop body
method {:verify true} MergeLoop(b: array<int>, c: array<int>, d: array<int>,i0: nat , j0: nat) returns (i: nat, j: nat)
requires b != c && b != d && b.Length == c.Length + d.Length
requires Sorted(c[..]) && Sorted(d[..])
requires i0 <= c.Length && j0 <= d.Length && i0 + j0 <= b.Length
requires InvSubSet(b[..],c[..],d[..],i0,j0)
requires InvSorted(b[..],c[..],d[..],i0,j0)
requires i0 + j0 < b.Length
modifies b
ensures i <= c.Length && j <= d.Length && i + j <= b.Length
ensures InvSubSet(b[..],c[..],d[..],i,j)
ensures InvSorted(b[..],c[..],d[..],i,j)
//decreases ensures
ensures 0 <= c.Length - i < c.Length - i0 || (c.Length - i == c.Length - i0 && 0 <= d.Length - j < d.Length - j0)
{
i,j := i0,j0;
if(i == c.Length || (j< d.Length && d[j] < c[i])){
// in this case we take the next value from d
b[i+j] := d[j];
lemmaInvSubsetTakeValueFromD(b[..],c[..],d[..],i,j);
j := j + 1;
}
else{
// in this case we take the next value from c
b[i+j] := c[i];
lemmaInvSubsetTakeValueFromC(b[..],c[..],d[..],i,j);
i := i + 1;
}
}
//Loop invariant - b is sprted so far and the next two potential values that will go into b are bigger then the biggest value in b.
ghost predicate InvSorted(b: seq<int>, c: seq<int>, d: seq<int>, i: nat, j: nat){
i <= |c| && j <= |d| && i + j <= |b| &&
((i+j > 0 && i < |c|) ==> (b[j + i - 1] <= c[i])) &&
((i+j > 0 && j < |d|) ==> (b[j + i - 1] <= d[j])) &&
Sorted(b[..i+j])
}
//Loop invariant - the multiset of the prefix of b so far is the same multiset as the prefixes of c and d so far.
ghost predicate InvSubSet(b: seq<int>, c: seq<int>, d: seq<int>, i: nat, j: nat){
i <= |c| && j <= |d| && i + j <= |b| &&
multiset(b[..i+j]) == multiset(c[..i]) + multiset(d[..j])
}
//This lemma helps dafny see that if the prefixs of arrays are the same multiset until the end of the arrays,
//all the arrays are the same multiset.
lemma LemmaMultysetsEquals (b: seq<int>, c: seq<int>, d: seq<int>, i: nat, j: nat)
requires i == |c|;
requires j == |d|;
requires i + j == |b|;
requires multiset(b[..i+j]) == multiset(c[..i]) + multiset(d[..j])
ensures multiset(b[..]) == multiset(c[..])+multiset(d[..]);
{
}
//This lemma helps dafny see that after adding the next value from c to b the prefixes are still the same subsets.
lemma lemmaInvSubsetTakeValueFromC (b: seq<int>, c: seq<int>, d: seq<int>, i: nat, j: nat)
requires i < |c|;
requires j <= |d|;
requires i + j < |b|;
requires |c| + |d| == |b|;
requires multiset(b[..i+j]) == multiset(c[..i]) + multiset(d[..j])
requires b[i+j] == c[i]
ensures multiset(b[..i+j+1]) == multiset(c[..i+1])+multiset(d[..j])
{
}
//This lemma helps dafny see that after adding the next value from d to b the prefixes are still the same subsets.
lemma{:verify true} lemmaInvSubsetTakeValueFromD (b: seq<int>, c: seq<int>, d: seq<int>, i: nat, j: nat)
requires i <= |c|;
requires j < |d|;
requires i + j < |b|;
requires |c| + |d| == |b|;
requires multiset(b[..i+j]) == multiset(c[..i]) + multiset(d[..j])
requires b[i+j] == d[j]
ensures multiset(b[..i+j+1]) == multiset(c[..i])+multiset(d[..j+1])
{
}
method Main() {
var a := new int[3] [4, 8, 6];
var q0 := a[..];
a := MergeSort(a);
print "\nThe sorted version of ", q0, " is ", a[..];
a := new int[5] [3, 8, 5, -1, 10];
q0 := a[..];
a := MergeSort(a);
print "\nThe sorted version of ", q0, " is ", a[..];
//assert a[..] == [-1, 3, 5, 8, 10];
}
| // Noa Leron 207131871
// Tsuri Farhana 315016907
predicate Sorted(q: seq<int>) {
forall i,j :: 0 <= i <= j < |q| ==> q[i] <= q[j]
}
/*
Goal: Implement the well known merge sort algorithm in O(a.Length X log_2(a.Length)) time, recursively.
- Divide the contents of the original array into two local arrays
- After sorting the local arrays (recursively), merge the contents of the two returned arrays using the Merge method (see below)
- DO NOT modify the specification or any other part of the method's signature
- DO NOT introduce any further methods
*/
method MergeSort(a: array<int>) returns (b: array<int>)
ensures b.Length == a.Length && Sorted(b[..]) && multiset(a[..]) == multiset(b[..])
decreases a.Length
{
if (a.Length <= 1) {b := a;}
else{
var mid: nat := a.Length / 2;
var a1: array<int> := new int[mid];
var a2: array<int> := new int[a.Length - mid];
assert a1.Length <= a2.Length;
assert a.Length == a1.Length + a2.Length;
var i: nat := 0;
while (i < a1.Length )
invariant Inv(a[..], a1[..], a2[..], i, mid)
decreases a1.Length - i
{
a1[i] := a[i];
a2[i] := a[i+mid];
i:=i+1;
}
assert !(i < a1.Length);
assert (i >= a1.Length);
assert i == a1.Length;
assert Inv(a[..], a1[..], a2[..], i, mid);
assert (i <= |a1[..]|) && (i <= |a2[..]|) && (i+mid <= |a[..]|);
assert (a1[..i] == a[..i]) && (a2[..i] == a[mid..(i+mid)]);
if(a1.Length < a2.Length) {
a2[i] := a[i+mid];
assert i+1 == a2.Length;
assert (a2[..i+1] == a[mid..(i+1+mid)]);
assert (a1[..i] == a[..i]) && (a2[..i+1] == a[mid..(i+1+mid)]);
assert a[..i] + a[i..i+1+mid] == a1[..i] + a2[..i+1];
assert a[..i] + a[i..i+1+mid] == a1[..] + a2[..];
assert a[..] == a1[..] + a2[..];
} // If a.Length is odd.
else{
assert i == a2.Length;
assert (a1[..i] == a[..i]) && (a2[..i] == a[mid..(i+mid)]);
assert a[..i] + a[i..i+mid] == a1[..i] + a2[..i];
assert a[..i] + a[i..i+mid] == a1[..] + a2[..];
assert a[..] == a1[..] + a2[..];
}
assert a1.Length < a.Length;
a1:= MergeSort(a1);
assert a2.Length < a.Length;
a2:= MergeSort(a2);
b := new int [a.Length];
Merge(b, a1, a2);
assert multiset(b[..]) == multiset(a1[..]) + multiset(a2[..]);
assert Sorted(b[..]);
}
assert b.Length == a.Length && Sorted(b[..]) && multiset(a[..]) == multiset(b[..]);
}
ghost predicate Inv(a: seq<int>, a1: seq<int>, a2: seq<int>, i: nat, mid: nat){
(i <= |a1|) && (i <= |a2|) && (i+mid <= |a|) &&
(a1[..i] == a[..i]) && (a2[..i] == a[mid..(i+mid)])
}
/*
Goal: Implement iteratively, correctly, efficiently, clearly
DO NOT modify the specification or any other part of the method's signature
*/
method Merge(b: array<int>, c: array<int>, d: array<int>)
requires b != c && b != d && b.Length == c.Length + d.Length
requires Sorted(c[..]) && Sorted(d[..])
ensures Sorted(b[..]) && multiset(b[..]) == multiset(c[..])+multiset(d[..])
modifies b
{
var i: nat, j: nat := 0, 0;
while i + j < b.Length
invariant i <= c.Length && j <= d.Length && i + j <= b.Length
invariant InvSubSet(b[..],c[..],d[..],i,j)
invariant InvSorted(b[..],c[..],d[..],i,j)
decreases c.Length-i, d.Length-j
{
i,j := MergeLoop (b,c,d,i,j);
assert InvSubSet(b[..],c[..],d[..],i,j);
assert InvSorted(b[..],c[..],d[..],i,j);
}
assert InvSubSet(b[..],c[..],d[..],i,j);
LemmaMultysetsEquals(b[..],c[..],d[..],i,j);
assert multiset(b[..]) == multiset(c[..])+multiset(d[..]);
}
//This is a method that replace the loop body
method {:verify true} MergeLoop(b: array<int>, c: array<int>, d: array<int>,i0: nat , j0: nat) returns (i: nat, j: nat)
requires b != c && b != d && b.Length == c.Length + d.Length
requires Sorted(c[..]) && Sorted(d[..])
requires i0 <= c.Length && j0 <= d.Length && i0 + j0 <= b.Length
requires InvSubSet(b[..],c[..],d[..],i0,j0)
requires InvSorted(b[..],c[..],d[..],i0,j0)
requires i0 + j0 < b.Length
modifies b
ensures i <= c.Length && j <= d.Length && i + j <= b.Length
ensures InvSubSet(b[..],c[..],d[..],i,j)
ensures InvSorted(b[..],c[..],d[..],i,j)
//decreases ensures
ensures 0 <= c.Length - i < c.Length - i0 || (c.Length - i == c.Length - i0 && 0 <= d.Length - j < d.Length - j0)
{
i,j := i0,j0;
if(i == c.Length || (j< d.Length && d[j] < c[i])){
// in this case we take the next value from d
assert InvSorted(b[..][i+j:=d[j]],c[..],d[..],i,j+1);
b[i+j] := d[j];
lemmaInvSubsetTakeValueFromD(b[..],c[..],d[..],i,j);
assert InvSubSet(b[..],c[..],d[..],i,j+1);
assert InvSorted(b[..],c[..],d[..],i,j+1);
j := j + 1;
}
else{
assert j == d.Length || (i < c.Length && c[i] <= d[j]);
// in this case we take the next value from c
assert InvSorted(b[..][i+j:=c[i]],c[..],d[..],i+1,j);
b[i+j] := c[i];
lemmaInvSubsetTakeValueFromC(b[..],c[..],d[..],i,j);
assert InvSubSet(b[..],c[..],d[..],i+1,j);
assert InvSorted(b[..],c[..],d[..],i+1,j);
i := i + 1;
}
}
//Loop invariant - b is sprted so far and the next two potential values that will go into b are bigger then the biggest value in b.
ghost predicate InvSorted(b: seq<int>, c: seq<int>, d: seq<int>, i: nat, j: nat){
i <= |c| && j <= |d| && i + j <= |b| &&
((i+j > 0 && i < |c|) ==> (b[j + i - 1] <= c[i])) &&
((i+j > 0 && j < |d|) ==> (b[j + i - 1] <= d[j])) &&
Sorted(b[..i+j])
}
//Loop invariant - the multiset of the prefix of b so far is the same multiset as the prefixes of c and d so far.
ghost predicate InvSubSet(b: seq<int>, c: seq<int>, d: seq<int>, i: nat, j: nat){
i <= |c| && j <= |d| && i + j <= |b| &&
multiset(b[..i+j]) == multiset(c[..i]) + multiset(d[..j])
}
//This lemma helps dafny see that if the prefixs of arrays are the same multiset until the end of the arrays,
//all the arrays are the same multiset.
lemma LemmaMultysetsEquals (b: seq<int>, c: seq<int>, d: seq<int>, i: nat, j: nat)
requires i == |c|;
requires j == |d|;
requires i + j == |b|;
requires multiset(b[..i+j]) == multiset(c[..i]) + multiset(d[..j])
ensures multiset(b[..]) == multiset(c[..])+multiset(d[..]);
{
assert b[..] == b[..i+j];
assert c[..] == c[..i];
assert d[..] == d[..j];
}
//This lemma helps dafny see that after adding the next value from c to b the prefixes are still the same subsets.
lemma lemmaInvSubsetTakeValueFromC (b: seq<int>, c: seq<int>, d: seq<int>, i: nat, j: nat)
requires i < |c|;
requires j <= |d|;
requires i + j < |b|;
requires |c| + |d| == |b|;
requires multiset(b[..i+j]) == multiset(c[..i]) + multiset(d[..j])
requires b[i+j] == c[i]
ensures multiset(b[..i+j+1]) == multiset(c[..i+1])+multiset(d[..j])
{
assert c[..i]+[c[i]] == c[..i+1];
assert b[..i+j+1] == b[..i+j] + [b[i+j]];
assert multiset(b[..i+j+1]) == multiset(c[..i+1])+multiset(d[..j]);
}
//This lemma helps dafny see that after adding the next value from d to b the prefixes are still the same subsets.
lemma{:verify true} lemmaInvSubsetTakeValueFromD (b: seq<int>, c: seq<int>, d: seq<int>, i: nat, j: nat)
requires i <= |c|;
requires j < |d|;
requires i + j < |b|;
requires |c| + |d| == |b|;
requires multiset(b[..i+j]) == multiset(c[..i]) + multiset(d[..j])
requires b[i+j] == d[j]
ensures multiset(b[..i+j+1]) == multiset(c[..i])+multiset(d[..j+1])
{
assert d[..j]+[d[j]] == d[..j+1];
assert b[..i+j+1] == b[..i+j] + [b[i+j]];
assert multiset(b[..i+j+1]) == multiset(c[..i])+multiset(d[..j+1]);
}
method Main() {
var a := new int[3] [4, 8, 6];
var q0 := a[..];
assert q0 == [4,8,6];
a := MergeSort(a);
assert a.Length == |q0| && multiset(a[..]) == multiset(q0);
print "\nThe sorted version of ", q0, " is ", a[..];
assert Sorted(a[..]);
assert a[..] == [4, 6, 8];
a := new int[5] [3, 8, 5, -1, 10];
q0 := a[..];
assert q0 == [3, 8, 5, -1, 10];
a := MergeSort(a);
assert a.Length == |q0| && multiset(a[..]) == multiset(q0);
print "\nThe sorted version of ", q0, " is ", a[..];
assert Sorted(a[..]);
//assert a[..] == [-1, 3, 5, 8, 10];
}
| AssertivePrograming_tmp_tmpwf43uz0e_MergeSort.dfy | 2 |
//Bubblesort CS 494 submission
//References: https://stackoverflow.com/questions/69364687/how-to-prove-time-complexity-of-bubble-sort-using-dafny/69365785#69365785
// predicate checks if elements of a are in ascending order, two additional conditions are added to allow us to sort in specific range within array
predicate sorted(a:array<int>, from:int, to:int)
requires a != null; // requires array to have n amount of elements
reads a;
requires 0 <= from <= to <= a.Length; // pre condition checks that from is the start of the range and to is the end of the range, requires values to be within 0 - a.Length
{
forall x, y :: from <= x < y < to ==> a[x] <= a[y]
}
//helps ensure swapping is valid, it is used inside the nested while loop to make sure linear order is being kept
predicate pivot(a:array<int>, to:int, pvt:int)
requires a != null; // requires array to have n amount of elements
reads a;
requires 0 <= pvt < to <= a.Length;
{
forall x, y :: 0 <= x < pvt < y < to ==> a[x] <= a[y] // all values within the array should be in ascending order
}
// Here having the algorithm for the bubblesort
method BubbleSort (a: array<int>)
requires a != null && a.Length > 0; // makes sure a is not empty and length is greater than 0
modifies a; // as method runs, we are changing a
ensures sorted(a, 0, a.Length); // makes sure elements of array a are sorted from 0 - a.Length
ensures multiset(a[..]) == multiset(old(a[..])); // Since a is being modified, we deference the heap
//and compare the previous elements to current elements.
{
var i := 1;
while (i < a.Length)
{
var j := i;
//this while loop inherits any previous pre/post conditions. It checks that
while (j > 0)
{
// Here it also simplifies the remaining invariants to handle the empty array.
if (a[j-1] > a[j]) { // reverse iterate through range within the array
a[j - 1], a[j] := a[j], a[j - 1]; // swaps objects if the IF condition is met
}
j := j - 1; // decrement j
}
i := i+1; // increment i
}
}
| //Bubblesort CS 494 submission
//References: https://stackoverflow.com/questions/69364687/how-to-prove-time-complexity-of-bubble-sort-using-dafny/69365785#69365785
// predicate checks if elements of a are in ascending order, two additional conditions are added to allow us to sort in specific range within array
predicate sorted(a:array<int>, from:int, to:int)
requires a != null; // requires array to have n amount of elements
reads a;
requires 0 <= from <= to <= a.Length; // pre condition checks that from is the start of the range and to is the end of the range, requires values to be within 0 - a.Length
{
forall x, y :: from <= x < y < to ==> a[x] <= a[y]
}
//helps ensure swapping is valid, it is used inside the nested while loop to make sure linear order is being kept
predicate pivot(a:array<int>, to:int, pvt:int)
requires a != null; // requires array to have n amount of elements
reads a;
requires 0 <= pvt < to <= a.Length;
{
forall x, y :: 0 <= x < pvt < y < to ==> a[x] <= a[y] // all values within the array should be in ascending order
}
// Here having the algorithm for the bubblesort
method BubbleSort (a: array<int>)
requires a != null && a.Length > 0; // makes sure a is not empty and length is greater than 0
modifies a; // as method runs, we are changing a
ensures sorted(a, 0, a.Length); // makes sure elements of array a are sorted from 0 - a.Length
ensures multiset(a[..]) == multiset(old(a[..])); // Since a is being modified, we deference the heap
//and compare the previous elements to current elements.
{
var i := 1;
while (i < a.Length)
invariant i <= a.Length; // more-or-less validates while loop condition during coputations
invariant sorted(a, 0, i); // Checks that for each increment of i, the array stays sorted, causing the
invariant multiset(a[..]) == multiset(old(a[..])); //makes sure elements that existed in previous heap for a are presnt in current run
{
var j := i;
//this while loop inherits any previous pre/post conditions. It checks that
while (j > 0)
invariant multiset(a[..]) == multiset(old(a[..]));
invariant sorted(a, 0, j); // O(n^2) runtime. Makes sure that a[0] - a[j] is sorted
invariant sorted(a, j, i+1); // then makes sure from a[j] - a[i+1] is sorted
invariant pivot(a, i+1, j); // important for ensuring that each computation is correct after swapping
{
// Here it also simplifies the remaining invariants to handle the empty array.
if (a[j-1] > a[j]) { // reverse iterate through range within the array
a[j - 1], a[j] := a[j], a[j - 1]; // swaps objects if the IF condition is met
}
j := j - 1; // decrement j
}
i := i+1; // increment i
}
}
| CS494-final-project_tmp_tmp7nof55uq_bubblesort.dfy | 3 |
class LFUCache {
var capacity : int;
var cacheMap : map<int, (int, int)>; //key -> {value, freq}
constructor(capacity: int)
requires capacity > 0;
ensures Valid();
{
this.capacity := capacity;
this.cacheMap := map[];
}
predicate Valid()
reads this;
// reads this.freqMap.Values;
{
// general value check
this.capacity > 0 &&
0 <= |cacheMap| <= capacity &&
(|cacheMap| > 0 ==> (forall e :: e in cacheMap ==> cacheMap[e].1 >= 1)) && // frequency should always larger than 0
(|cacheMap| > 0 ==> (forall e :: e in cacheMap ==> cacheMap[e].0 >= 0)) // only allow positive values
}
method getLFUKey() returns (lfuKey : int)
requires Valid();
requires |cacheMap| > 0;
ensures Valid();
ensures lfuKey in cacheMap;
ensures forall k :: k in cacheMap.Items ==> cacheMap[lfuKey].1 <= cacheMap[k.0].1;
{
var items := cacheMap.Items;
var seenItems := {};
var anyItem :| anyItem in items;
var minFreq := anyItem.1.1;
lfuKey := anyItem.0;
while items != {}
{
var item :| item in items;
if (item.1.1 < minFreq) {
lfuKey := item.0;
minFreq := item.1.1;
}
items := items - { item };
seenItems := seenItems + { item };
}
// assert forall k :: k in cacheMap ==> cacheMap[lfuKey].1 <= cacheMap[k].1; // ????
return lfuKey;
}
method get(key: int) returns (value: int)
requires Valid();
modifies this;
ensures Valid();
ensures key !in cacheMap ==> value == -1;
ensures forall e :: e in old(cacheMap) <==> e in cacheMap;
ensures forall e :: e in old(cacheMap) ==> (old(cacheMap[e].0) == cacheMap[e].0);
ensures key in cacheMap ==> value == cacheMap[key].0 && old(cacheMap[key].1) == cacheMap[key].1-1;
{
if(key !in cacheMap) {
value := -1;
}
else{
value := cacheMap[key].0;
var oldFreq := cacheMap[key].1;
var newV := (value, oldFreq + 1);
cacheMap := cacheMap[key := newV];
}
print "after get: ";
print cacheMap;
print "\n";
return value;
}
method put(key: int, value: int)
requires Valid();
requires value > 0;
modifies this
ensures Valid();
{
if (key in cacheMap) {
var currFreq := cacheMap[key].1;
cacheMap := cacheMap[key := (value, currFreq)];
} else {
if (|cacheMap| < capacity) {
cacheMap := cacheMap[key := (value, 1)];
} else {
var LFUKey := getLFUKey();
ghost var oldMap := cacheMap;
var newMap := cacheMap - {LFUKey};
cacheMap := newMap;
ghost var oldCard := |oldMap|;
ghost var newCard := |newMap|;
cacheMap := cacheMap[key := (value, 1)];
}
}
print "after put: ";
print cacheMap;
print "\n";
}
}
method Main()
{
var LFUCache := new LFUCache(5);
print "Cache Capacity = 5 \n";
print "PUT (1, 1) - ";
LFUCache.put(1,1);
print "PUT (2, 2) - ";
LFUCache.put(2,2);
print "PUT (3, 3) - ";
LFUCache.put(3,3);
print "GET (1) - ";
var val := LFUCache.get(1);
print "get(1) = ";
print val;
print "\n";
print "PUT (3, 5) - ";
LFUCache.put(3,5);
print "GET (3) - ";
val := LFUCache.get(3);
print "get(3) = ";
print val;
print "\n";
print "PUT (4, 6) - ";
LFUCache.put(4,6);
print "PUT (5, 7) - ";
LFUCache.put(5,7);
print "PUT (10, 100) - ";
LFUCache.put(10,100);
print "GET (2) - ";
val := LFUCache.get(2);
print "get(2) = ";
print val;
print "\n";
}
| class LFUCache {
var capacity : int;
var cacheMap : map<int, (int, int)>; //key -> {value, freq}
constructor(capacity: int)
requires capacity > 0;
ensures Valid();
{
this.capacity := capacity;
this.cacheMap := map[];
}
predicate Valid()
reads this;
// reads this.freqMap.Values;
{
// general value check
this.capacity > 0 &&
0 <= |cacheMap| <= capacity &&
(|cacheMap| > 0 ==> (forall e :: e in cacheMap ==> cacheMap[e].1 >= 1)) && // frequency should always larger than 0
(|cacheMap| > 0 ==> (forall e :: e in cacheMap ==> cacheMap[e].0 >= 0)) // only allow positive values
}
method getLFUKey() returns (lfuKey : int)
requires Valid();
requires |cacheMap| > 0;
ensures Valid();
ensures lfuKey in cacheMap;
ensures forall k :: k in cacheMap.Items ==> cacheMap[lfuKey].1 <= cacheMap[k.0].1;
{
var items := cacheMap.Items;
var seenItems := {};
var anyItem :| anyItem in items;
var minFreq := anyItem.1.1;
lfuKey := anyItem.0;
while items != {}
decreases |items|;
invariant cacheMap.Items >= items;
invariant cacheMap.Items >= seenItems;
invariant cacheMap.Items == seenItems + items;
invariant lfuKey in cacheMap;
invariant cacheMap[lfuKey].1 == minFreq;
invariant forall e :: e in seenItems ==> minFreq <= e.1.1;
invariant forall e :: e in seenItems ==> minFreq <= cacheMap[e.0].1;
invariant forall e :: e in seenItems ==> cacheMap[lfuKey].1 <= cacheMap[e.0].1;
invariant exists e :: e in seenItems + items ==> minFreq == e.1.1;
{
var item :| item in items;
if (item.1.1 < minFreq) {
lfuKey := item.0;
minFreq := item.1.1;
}
items := items - { item };
seenItems := seenItems + { item };
}
assert seenItems == cacheMap.Items;
assert cacheMap[lfuKey].1 == minFreq;
assert forall e :: e in seenItems ==> minFreq <= e.1.1;
assert forall e :: e in cacheMap.Items ==> minFreq <= e.1.1;
assert forall k :: k in seenItems ==> cacheMap[lfuKey].1 <= cacheMap[k.0].1;
assert forall k :: k in cacheMap.Items ==> cacheMap[lfuKey].1 <= cacheMap[k.0].1;
// assert forall k :: k in cacheMap ==> cacheMap[lfuKey].1 <= cacheMap[k].1; // ????
return lfuKey;
}
method get(key: int) returns (value: int)
requires Valid();
modifies this;
ensures Valid();
ensures key !in cacheMap ==> value == -1;
ensures forall e :: e in old(cacheMap) <==> e in cacheMap;
ensures forall e :: e in old(cacheMap) ==> (old(cacheMap[e].0) == cacheMap[e].0);
ensures key in cacheMap ==> value == cacheMap[key].0 && old(cacheMap[key].1) == cacheMap[key].1-1;
{
assert key in cacheMap ==> cacheMap[key].0 >= 0;
if(key !in cacheMap) {
value := -1;
}
else{
assert key in cacheMap;
assert cacheMap[key].0 >= 0;
value := cacheMap[key].0;
var oldFreq := cacheMap[key].1;
var newV := (value, oldFreq + 1);
cacheMap := cacheMap[key := newV];
}
print "after get: ";
print cacheMap;
print "\n";
return value;
}
method put(key: int, value: int)
requires Valid();
requires value > 0;
modifies this
ensures Valid();
{
if (key in cacheMap) {
var currFreq := cacheMap[key].1;
cacheMap := cacheMap[key := (value, currFreq)];
} else {
if (|cacheMap| < capacity) {
cacheMap := cacheMap[key := (value, 1)];
} else {
var LFUKey := getLFUKey();
assert LFUKey in cacheMap;
assert |cacheMap| == capacity;
ghost var oldMap := cacheMap;
var newMap := cacheMap - {LFUKey};
cacheMap := newMap;
assert newMap == cacheMap - {LFUKey};
assert LFUKey !in cacheMap;
assert LFUKey in oldMap;
ghost var oldCard := |oldMap|;
ghost var newCard := |newMap|;
assert |cacheMap.Keys| < |oldMap|; // ????
cacheMap := cacheMap[key := (value, 1)];
}
}
print "after put: ";
print cacheMap;
print "\n";
}
}
method Main()
{
var LFUCache := new LFUCache(5);
print "Cache Capacity = 5 \n";
print "PUT (1, 1) - ";
LFUCache.put(1,1);
print "PUT (2, 2) - ";
LFUCache.put(2,2);
print "PUT (3, 3) - ";
LFUCache.put(3,3);
print "GET (1) - ";
var val := LFUCache.get(1);
print "get(1) = ";
print val;
print "\n";
print "PUT (3, 5) - ";
LFUCache.put(3,5);
print "GET (3) - ";
val := LFUCache.get(3);
print "get(3) = ";
print val;
print "\n";
print "PUT (4, 6) - ";
LFUCache.put(4,6);
print "PUT (5, 7) - ";
LFUCache.put(5,7);
print "PUT (10, 100) - ";
LFUCache.put(10,100);
print "GET (2) - ";
val := LFUCache.get(2);
print "get(2) = ";
print val;
print "\n";
}
| CS5232_Project_tmp_tmpai_cfrng_LFUSimple.dfy | 4 |
iterator Gen(start: int) yields (x: int)
yield ensures |xs| <= 10 && x == start + |xs| - 1
{
var i := 0;
while i < 10 invariant |xs| == i {
x := start + i;
yield;
i := i + 1;
}
}
method Main() {
var i := new Gen(30);
while true
{
var m := i.MoveNext();
if (!m) {break; }
print i.x;
}
}
| iterator Gen(start: int) yields (x: int)
yield ensures |xs| <= 10 && x == start + |xs| - 1
{
var i := 0;
while i < 10 invariant |xs| == i {
x := start + i;
yield;
i := i + 1;
}
}
method Main() {
var i := new Gen(30);
while true
invariant i.Valid() && fresh(i._new)
decreases 10 - |i.xs|
{
var m := i.MoveNext();
if (!m) {break; }
print i.x;
}
}
| CS5232_Project_tmp_tmpai_cfrng_test.dfy | 5 |
method Max (x: nat, y:nat) returns (r:nat)
ensures (r >= x && r >=y)
ensures (r == x || r == y)
{
if (x >= y) { r := x;}
else { r := y;}
}
method Test ()
{
var result := Max(42, 73);
}
method m1 (x: int, y: int) returns (z: int)
requires 0 < x < y
ensures z >= 0 && z <= y && z != x
{
//assume 0 < x < y
z := 0;
}
function fib (n: nat) : nat
{
if n == 0 then 1 else
if n == 1 then 1 else
fib(n -1) + fib (n-2)
}
method Fib (n: nat) returns (r:nat)
ensures r == fib(n)
{
if (n == 0) {
return 1;
}
r := 1;
var next:=2;
var i := 1;
while i < n
{
var tmp:=next;
next:= next + r;
r:= tmp;
i:= i + 1;
}
return r;
}
datatype List<T> = Nil | Cons(head: T, tail: List<T>)
function add(l:List<int>) : int
{
match l
case Nil => 0
case Cons(x, xs) => x + add(xs)
}
method addImp (l: List<int>) returns (s: int)
ensures s == add(l)
{
var ll := l;
s := 0;
while ll != Nil
{
s := s + ll.head;
ll:= ll.tail;
}
}
method MaxA (a: array<int>) returns (m: int)
requires a.Length > 0
ensures forall i :: 0 <= i < a.Length ==> a[i] <= m
ensures exists i :: 0 <= i < a.Length && a[i] == m
{
m := a[0];
var i := 1;
while i< a.Length
{
if a[i] > m {
m:= a[i];
}
i := i +1;
}
}
| method Max (x: nat, y:nat) returns (r:nat)
ensures (r >= x && r >=y)
ensures (r == x || r == y)
{
if (x >= y) { r := x;}
else { r := y;}
}
method Test ()
{
var result := Max(42, 73);
assert result == 73;
}
method m1 (x: int, y: int) returns (z: int)
requires 0 < x < y
ensures z >= 0 && z <= y && z != x
{
//assume 0 < x < y
z := 0;
}
function fib (n: nat) : nat
{
if n == 0 then 1 else
if n == 1 then 1 else
fib(n -1) + fib (n-2)
}
method Fib (n: nat) returns (r:nat)
ensures r == fib(n)
{
if (n == 0) {
return 1;
}
r := 1;
var next:=2;
var i := 1;
while i < n
invariant 1 <= i <= n
invariant r == fib(i)
invariant next == fib(i+1)
{
var tmp:=next;
next:= next + r;
r:= tmp;
i:= i + 1;
}
assert r == fib(n);
return r;
}
datatype List<T> = Nil | Cons(head: T, tail: List<T>)
function add(l:List<int>) : int
{
match l
case Nil => 0
case Cons(x, xs) => x + add(xs)
}
method addImp (l: List<int>) returns (s: int)
ensures s == add(l)
{
var ll := l;
s := 0;
while ll != Nil
decreases ll
invariant add(l) == s + add(ll)
{
s := s + ll.head;
ll:= ll.tail;
}
assert s == add(l);
}
method MaxA (a: array<int>) returns (m: int)
requires a.Length > 0
ensures forall i :: 0 <= i < a.Length ==> a[i] <= m
ensures exists i :: 0 <= i < a.Length && a[i] == m
{
m := a[0];
var i := 1;
while i< a.Length
invariant 1 <= i <= a.Length
invariant forall j :: 0 <= j < i ==> a[j] <=m
invariant exists j :: 0 <= j < i && a[j] ==m
{
if a[i] > m {
m:= a[i];
}
i := i +1;
}
}
| CVS-Projto1_tmp_tmpb1o0bu8z_Hoare.dfy | 6 |
//Exercicio 1.a)
function sum (a:array<int>, i:int, j:int) :int
reads a
requires 0 <= i <= j <= a.Length
{
if i == j then
0
else
a[j-1] + sum(a, i, j-1)
}
//Exercicio 1.b)
method query (a:array<int>, i:int, j:int) returns (s:int)
requires 0 <= i <= j <= a.Length
ensures s == sum(a, i, j)
{
s := 0;
var aux := i;
while (aux < j)
{
s := s + a[aux];
aux := aux + 1;
}
return s;
}
//Exercicio 1.c)
lemma queryLemma(a:array<int>, i:int, j:int, k:int)
requires 0 <= i <= k <= j <= a.Length
ensures sum(a,i,k) + sum(a,k,j) == sum(a,i,j)
{
}
method queryFast (a:array<int>, c:array<int>, i:int, j:int) returns (r:int)
requires is_prefix_sum_for(a,c) && 0 <= i <= j <= a.Length < c.Length
ensures r == sum(a, i,j)
{
r := c[j] - c[i];
queryLemma(a,0,j,i);
return r;
}
predicate is_prefix_sum_for (a:array<int>, c:array<int>)
reads c, a
{
a.Length + 1 == c.Length
&& c[0] == 0
&& forall j :: 1 <= j <= a.Length ==> c[j] == sum(a,0,j)
}
///Exercicio 2.
datatype List<T> = Nil | Cons(head: T, tail: List<T>)
method from_array<T>(a: array<T>) returns (l: List<T>)
requires a.Length > 0
ensures forall j::0 <= j < a.Length ==> mem(a[j],l)
{
var i:= a.Length-1;
l:= Nil;
while (i >= 0)
{
l := Cons(a[i], l);
i := i - 1;
}
return l;
}
function mem<T(==)> (x: T, l:List<T>) : bool
{
match l
case Nil => false
case Cons(y,r)=> if (x==y) then true else mem(x,r)
}
| //Exercicio 1.a)
function sum (a:array<int>, i:int, j:int) :int
decreases j
reads a
requires 0 <= i <= j <= a.Length
{
if i == j then
0
else
a[j-1] + sum(a, i, j-1)
}
//Exercicio 1.b)
method query (a:array<int>, i:int, j:int) returns (s:int)
requires 0 <= i <= j <= a.Length
ensures s == sum(a, i, j)
{
s := 0;
var aux := i;
while (aux < j)
invariant i <= aux <= j
invariant s == sum(a, i, aux)
decreases j - aux
{
s := s + a[aux];
aux := aux + 1;
}
return s;
}
//Exercicio 1.c)
lemma queryLemma(a:array<int>, i:int, j:int, k:int)
requires 0 <= i <= k <= j <= a.Length
ensures sum(a,i,k) + sum(a,k,j) == sum(a,i,j)
{
}
method queryFast (a:array<int>, c:array<int>, i:int, j:int) returns (r:int)
requires is_prefix_sum_for(a,c) && 0 <= i <= j <= a.Length < c.Length
ensures r == sum(a, i,j)
{
r := c[j] - c[i];
queryLemma(a,0,j,i);
return r;
}
predicate is_prefix_sum_for (a:array<int>, c:array<int>)
reads c, a
{
a.Length + 1 == c.Length
&& c[0] == 0
&& forall j :: 1 <= j <= a.Length ==> c[j] == sum(a,0,j)
}
///Exercicio 2.
datatype List<T> = Nil | Cons(head: T, tail: List<T>)
method from_array<T>(a: array<T>) returns (l: List<T>)
requires a.Length > 0
ensures forall j::0 <= j < a.Length ==> mem(a[j],l)
{
var i:= a.Length-1;
l:= Nil;
while (i >= 0)
invariant -1 <= i < a. Length
invariant forall j:: i+1 <= j < a.Length ==> mem(a[j],l)
{
l := Cons(a[i], l);
i := i - 1;
}
return l;
}
function mem<T(==)> (x: T, l:List<T>) : bool
decreases l
{
match l
case Nil => false
case Cons(y,r)=> if (x==y) then true else mem(x,r)
}
| CVS-Projto1_tmp_tmpb1o0bu8z_proj1_proj1.dfy | 7 |
/* Cumulative Sums over Arrays */
/*
Daniel Cavalheiro 57869
Pedro Nunes 57854
*/
//(a)
function sum(a: array<int>, i: int, j: int): int
reads a
requires 0 <= i <= j <= a.Length
{
if (i == j) then 0
else a[i] + sum(a, i+1, j)
}
//(b)
method query(a: array<int>, i: int, j: int) returns (res:int)
requires 0 <= i <= j <= a.Length
ensures res == sum(a, i, j)
{
res := 0;
var k := i;
while(k < j)
{
res := res + a[k];
k := k + 1;
}
}
//(c)
predicate is_prefix_sum_for (a: array<int>, c: array<int>)
requires a.Length + 1 == c.Length
requires c[0] == 0
reads c, a
{
forall i: int :: 0 <= i < a.Length ==> c[i+1] == c[i] + a[i]
}
lemma aux(a: array<int>, c: array<int>, i: int, j: int)
requires 0 <= i <= j <= a.Length
requires a.Length + 1 == c.Length
requires c[0] == 0
requires is_prefix_sum_for(a, c)
ensures forall k: int :: i <= k <= j ==> sum(a, i, k) + sum(a, k, j) == c[k] - c[i] + c[j] - c[k] //sum(a, i, j) == c[j] - c[i]
{}
method queryFast(a: array<int>, c: array<int>, i: int, j: int) returns (r: int)
requires a.Length + 1 == c.Length && c[0] == 0
requires 0 <= i <= j <= a.Length
requires is_prefix_sum_for(a,c)
ensures r == sum(a, i, j)
{
aux(a, c, i, j);
r := c[j] - c[i];
}
method Main()
{
var x := new int[10];
x[0], x[1], x[2], x[3] := 2, 2, 1, 5;
var y := sum(x, 0, x.Length);
//assert y == 10;
var c := new int[11];
c[0], c[1], c[2], c[3], c[4] := 0, 2, 4, 5, 10;
// var r := queryFast(x, c, 0, x.Length);
}
| /* Cumulative Sums over Arrays */
/*
Daniel Cavalheiro 57869
Pedro Nunes 57854
*/
//(a)
function sum(a: array<int>, i: int, j: int): int
reads a
requires 0 <= i <= j <= a.Length
decreases j - i
{
if (i == j) then 0
else a[i] + sum(a, i+1, j)
}
//(b)
method query(a: array<int>, i: int, j: int) returns (res:int)
requires 0 <= i <= j <= a.Length
ensures res == sum(a, i, j)
{
res := 0;
var k := i;
while(k < j)
invariant i <= k <= j <= a.Length
invariant res + sum(a, k, j) == sum(a, i, j)
{
res := res + a[k];
k := k + 1;
}
}
//(c)
predicate is_prefix_sum_for (a: array<int>, c: array<int>)
requires a.Length + 1 == c.Length
requires c[0] == 0
reads c, a
{
forall i: int :: 0 <= i < a.Length ==> c[i+1] == c[i] + a[i]
}
lemma aux(a: array<int>, c: array<int>, i: int, j: int)
requires 0 <= i <= j <= a.Length
requires a.Length + 1 == c.Length
requires c[0] == 0
requires is_prefix_sum_for(a, c)
decreases j - i
ensures forall k: int :: i <= k <= j ==> sum(a, i, k) + sum(a, k, j) == c[k] - c[i] + c[j] - c[k] //sum(a, i, j) == c[j] - c[i]
{}
method queryFast(a: array<int>, c: array<int>, i: int, j: int) returns (r: int)
requires a.Length + 1 == c.Length && c[0] == 0
requires 0 <= i <= j <= a.Length
requires is_prefix_sum_for(a,c)
ensures r == sum(a, i, j)
{
aux(a, c, i, j);
r := c[j] - c[i];
}
method Main()
{
var x := new int[10];
x[0], x[1], x[2], x[3] := 2, 2, 1, 5;
var y := sum(x, 0, x.Length);
//assert y == 10;
var c := new int[11];
c[0], c[1], c[2], c[3], c[4] := 0, 2, 4, 5, 10;
// var r := queryFast(x, c, 0, x.Length);
}
| CVS-handout1_tmp_tmptm52no3k_1.dfy | 8 |
/* Functional Lists and Imperative Arrays */
/*
Daniel Cavalheiro 57869
Pedro Nunes 57854
*/
datatype List<T> = Nil | Cons(head: T, tail: List<T>)
function length<T>(l: List<T>): nat
{
match l
case Nil => 0
case Cons(_, t) => 1 + length(t)
}
predicate mem<T(==)> (l: List<T>, x: T)
{
match l
case Nil => false
case Cons(h, t) => if(h == x) then true else mem(t, x)
}
function at<T>(l: List<T>, i: nat): T
requires i < length(l)
{
if i == 0 then l.head else at(l.tail, i - 1)
}
method from_array<T>(a: array<T>) returns (l: List<T>)
requires a.Length >= 0
ensures length(l) == a.Length
ensures forall i: int :: 0 <= i < length(l) ==> at(l, i) == a[i]
ensures forall x :: mem(l, x) ==> exists i: int :: 0 <= i < length(l) && a[i] == x
{
l := Nil;
var i: int := a.Length - 1;
while(i >= 0)
{
l := Cons(a[i], l);
i := i-1;
}
}
method Main() {
var l: List<int> := List.Cons(1, List.Cons(2, List.Cons(3, Nil)));
var arr: array<int> := new int [3](i => i + 1);
var t: List<int> := from_array(arr);
print l;
print "\n";
print t;
print "\n";
print t == l;
}
| /* Functional Lists and Imperative Arrays */
/*
Daniel Cavalheiro 57869
Pedro Nunes 57854
*/
datatype List<T> = Nil | Cons(head: T, tail: List<T>)
function length<T>(l: List<T>): nat
{
match l
case Nil => 0
case Cons(_, t) => 1 + length(t)
}
predicate mem<T(==)> (l: List<T>, x: T)
{
match l
case Nil => false
case Cons(h, t) => if(h == x) then true else mem(t, x)
}
function at<T>(l: List<T>, i: nat): T
requires i < length(l)
{
if i == 0 then l.head else at(l.tail, i - 1)
}
method from_array<T>(a: array<T>) returns (l: List<T>)
requires a.Length >= 0
ensures length(l) == a.Length
ensures forall i: int :: 0 <= i < length(l) ==> at(l, i) == a[i]
ensures forall x :: mem(l, x) ==> exists i: int :: 0 <= i < length(l) && a[i] == x
{
l := Nil;
var i: int := a.Length - 1;
while(i >= 0)
invariant -1 <= i <= a.Length - 1
invariant length(l) == a.Length - 1 - i
invariant forall j: int :: i < j < a.Length ==> at(l,j-i-1) == a[j]
invariant forall x :: mem(l, x) ==> exists k: int :: i < k < a.Length && a[k] == x
{
l := Cons(a[i], l);
i := i-1;
}
}
method Main() {
var l: List<int> := List.Cons(1, List.Cons(2, List.Cons(3, Nil)));
var arr: array<int> := new int [3](i => i + 1);
var t: List<int> := from_array(arr);
print l;
print "\n";
print t;
print "\n";
print t == l;
}
| CVS-handout1_tmp_tmptm52no3k_2.dfy | 9 |
method allDigits(s: string) returns (result: bool)
ensures result <==> (forall i :: 0 <= i < |s| ==> s[i] in "0123456789")
{
result:=true ;
for i := 0 to |s|
{
if ! (s[i] in "0123456789"){
return false;
}
}
}
| method allDigits(s: string) returns (result: bool)
ensures result <==> (forall i :: 0 <= i < |s| ==> s[i] in "0123456789")
{
result:=true ;
for i := 0 to |s|
invariant result <==> (forall ii :: 0 <= ii < i ==> s[ii] in "0123456789")
{
if ! (s[i] in "0123456789"){
return false;
}
}
}
| Clover_all_digits.dfy | 10 |
method append(a:array<int>, b:int) returns (c:array<int>)
ensures a[..] + [b] == c[..]
{
c := new int[a.Length+1];
var i:= 0;
while (i < a.Length)
{
c[i] := a[i];
i:=i+1;
}
c[a.Length]:=b;
}
| method append(a:array<int>, b:int) returns (c:array<int>)
ensures a[..] + [b] == c[..]
{
c := new int[a.Length+1];
var i:= 0;
while (i < a.Length)
invariant 0 <= i <= a.Length
invariant forall ii::0<=ii<i ==> c[ii]==a[ii]
{
c[i] := a[i];
i:=i+1;
}
c[a.Length]:=b;
}
| Clover_array_append.dfy | 11 |
method concat(a:array<int>, b:array<int>) returns (c:array<int>)
ensures c.Length==b.Length+a.Length
ensures forall k :: 0 <= k < a.Length ==> c[k] == a[k]
ensures forall k :: 0 <= k < b.Length ==> c[k+a.Length] == b[k]
{
c := new int[a.Length+b.Length];
var i:= 0;
while (i < c.Length)
{
c[i] := if i<a.Length then a[i] else b[i-a.Length];
i:=i+1;
}
}
| method concat(a:array<int>, b:array<int>) returns (c:array<int>)
ensures c.Length==b.Length+a.Length
ensures forall k :: 0 <= k < a.Length ==> c[k] == a[k]
ensures forall k :: 0 <= k < b.Length ==> c[k+a.Length] == b[k]
{
c := new int[a.Length+b.Length];
var i:= 0;
while (i < c.Length)
invariant 0 <= i <= c.Length
invariant if i<a.Length then c[..i]==a[..i] else c[..i]==a[..]+b[..(i-a.Length)]
{
c[i] := if i<a.Length then a[i] else b[i-a.Length];
i:=i+1;
}
}
| Clover_array_concat.dfy | 12 |
method iter_copy<T(0)>(s: array<T>) returns (t: array<T>)
ensures s.Length==t.Length
ensures forall i::0<=i<s.Length ==> s[i]==t[i]
{
t := new T[s.Length];
var i:= 0;
while (i < s.Length)
{
t[i] := s[i];
i:=i+1;
}
}
| method iter_copy<T(0)>(s: array<T>) returns (t: array<T>)
ensures s.Length==t.Length
ensures forall i::0<=i<s.Length ==> s[i]==t[i]
{
t := new T[s.Length];
var i:= 0;
while (i < s.Length)
invariant 0 <= i <= s.Length
invariant forall x :: 0 <= x < i ==> s[x] == t[x]
{
t[i] := s[i];
i:=i+1;
}
}
| Clover_array_copy.dfy | 13 |
method arrayProduct(a: array<int>, b: array<int>) returns (c: array<int> )
requires a.Length==b.Length
ensures c.Length==a.Length
ensures forall i:: 0 <= i< a.Length==> a[i] * b[i]==c[i]
{
c:= new int[a.Length];
var i:=0;
while i<a.Length
{
c[i]:=a[i]*b[i];
i:=i+1;
}
}
| method arrayProduct(a: array<int>, b: array<int>) returns (c: array<int> )
requires a.Length==b.Length
ensures c.Length==a.Length
ensures forall i:: 0 <= i< a.Length==> a[i] * b[i]==c[i]
{
c:= new int[a.Length];
var i:=0;
while i<a.Length
invariant 0<=i<=a.Length
invariant forall j:: 0 <= j< i==> a[j] * b[j]==c[j]
{
c[i]:=a[i]*b[i];
i:=i+1;
}
}
| Clover_array_product.dfy | 14 |
method arraySum(a: array<int>, b: array<int>) returns (c: array<int> )
requires a.Length==b.Length
ensures c.Length==a.Length
ensures forall i:: 0 <= i< a.Length==> a[i] + b[i]==c[i]
{
c:= new int[a.Length];
var i:=0;
while i<a.Length
{
c[i]:=a[i]+b[i];
i:=i+1;
}
}
| method arraySum(a: array<int>, b: array<int>) returns (c: array<int> )
requires a.Length==b.Length
ensures c.Length==a.Length
ensures forall i:: 0 <= i< a.Length==> a[i] + b[i]==c[i]
{
c:= new int[a.Length];
var i:=0;
while i<a.Length
invariant 0<=i<=a.Length
invariant forall j:: 0 <= j< i==> a[j] + b[j]==c[j]
{
c[i]:=a[i]+b[i];
i:=i+1;
}
}
| Clover_array_sum.dfy | 15 |
method below_zero(operations: seq<int>) returns (s:array<int>, result:bool)
ensures s.Length == |operations| + 1
ensures s[0]==0
ensures forall i :: 0 <= i < s.Length-1 ==> s[i+1]==s[i]+operations[i]
ensures result == true ==> (exists i :: 1 <= i <= |operations| && s[i] < 0)
ensures result == false ==> forall i :: 0 <= i < s.Length ==> s[i] >= 0
{
result := false;
s := new int[|operations| + 1];
var i := 0;
s[i] := 0;
while i < s.Length
{
if i>0{
s[i] := s[i - 1] + operations[i - 1];
}
i := i + 1;
}
i:=0;
while i < s.Length
{
if s[i] < 0 {
result := true;
return;
}
i := i + 1;
}
}
| method below_zero(operations: seq<int>) returns (s:array<int>, result:bool)
ensures s.Length == |operations| + 1
ensures s[0]==0
ensures forall i :: 0 <= i < s.Length-1 ==> s[i+1]==s[i]+operations[i]
ensures result == true ==> (exists i :: 1 <= i <= |operations| && s[i] < 0)
ensures result == false ==> forall i :: 0 <= i < s.Length ==> s[i] >= 0
{
result := false;
s := new int[|operations| + 1];
var i := 0;
s[i] := 0;
while i < s.Length
invariant 0 <= i <= s.Length
invariant s[0]==0
invariant s.Length == |operations| + 1
invariant forall x :: 0 <= x < i-1 ==> s[x+1]==s[x]+operations[x]
{
if i>0{
s[i] := s[i - 1] + operations[i - 1];
}
i := i + 1;
}
i:=0;
while i < s.Length
invariant 0 <= i <= s.Length
invariant forall x :: 0 <= x < i ==> s[x] >= 0
{
if s[i] < 0 {
result := true;
return;
}
i := i + 1;
}
}
| Clover_below_zero.dfy | 16 |
method BinarySearch(a: array<int>, key: int) returns (n: int)
requires forall i,j :: 0<=i<j<a.Length ==> a[i]<=a[j]
ensures 0<= n <=a.Length
ensures forall i :: 0<= i < n ==> a[i] < key
ensures n == a.Length ==> forall i :: 0 <= i < a.Length ==> a[i] < key
ensures forall i :: n<= i < a.Length ==> a[i]>=key
{
var lo, hi := 0, a.Length;
while lo<hi
{
var mid := (lo + hi) / 2;
if a[mid] < key {
lo := mid + 1;
} else {
hi := mid;
}
}
n:=lo;
}
| method BinarySearch(a: array<int>, key: int) returns (n: int)
requires forall i,j :: 0<=i<j<a.Length ==> a[i]<=a[j]
ensures 0<= n <=a.Length
ensures forall i :: 0<= i < n ==> a[i] < key
ensures n == a.Length ==> forall i :: 0 <= i < a.Length ==> a[i] < key
ensures forall i :: n<= i < a.Length ==> a[i]>=key
{
var lo, hi := 0, a.Length;
while lo<hi
invariant 0<= lo <= hi <= a.Length
invariant forall i :: 0<=i<lo ==> a[i] < key
invariant forall i :: hi<=i<a.Length ==> a[i] >= key
{
var mid := (lo + hi) / 2;
if a[mid] < key {
lo := mid + 1;
} else {
hi := mid;
}
}
n:=lo;
}
| Clover_binary_search.dfy | 17 |
method BubbleSort(a: array<int>)
modifies a
ensures forall i,j::0<= i < j < a.Length ==> a[i] <= a[j]
ensures multiset(a[..])==multiset(old(a[..]))
{
var i := a.Length - 1;
while (i > 0)
{
var j := 0;
while (j < i)
{
if (a[j] > a[j + 1])
{
a[j], a[j + 1] := a[j + 1], a[j];
}
j := j + 1;
}
i := i - 1;
}
}
| method BubbleSort(a: array<int>)
modifies a
ensures forall i,j::0<= i < j < a.Length ==> a[i] <= a[j]
ensures multiset(a[..])==multiset(old(a[..]))
{
var i := a.Length - 1;
while (i > 0)
invariant i < 0 ==> a.Length == 0
invariant -1 <= i < a.Length
invariant forall ii,jj::i <= ii< jj <a.Length ==> a[ii] <= a[jj]
invariant forall k,k'::0<=k<=i<k'<a.Length==>a[k]<=a[k']
invariant multiset(a[..])==multiset(old(a[..]))
{
var j := 0;
while (j < i)
invariant 0 < i < a.Length && 0 <= j <= i
invariant forall ii,jj::i<= ii <= jj <a.Length ==> a[ii] <= a[jj]
invariant forall k, k'::0<=k<=i<k'<a.Length==>a[k]<=a[k']
invariant forall k :: 0 <= k <= j ==> a[k] <= a[j]
invariant multiset(a[..])==multiset(old(a[..]))
{
if (a[j] > a[j + 1])
{
a[j], a[j + 1] := a[j + 1], a[j];
}
j := j + 1;
}
i := i - 1;
}
}
| Clover_bubble_sort.dfy | 18 |
method CalDiv() returns (x:int, y:int)
ensures x==191/7
ensures y==191%7
{
x, y := 0, 191;
while 7 <= y
{
x := x+1;
y:=191-7*x;
}
}
| method CalDiv() returns (x:int, y:int)
ensures x==191/7
ensures y==191%7
{
x, y := 0, 191;
while 7 <= y
invariant 0 <= y && 7 * x + y == 191
{
x := x+1;
y:=191-7*x;
}
}
| Clover_cal_ans.dfy | 19 |
method Sum(N:int) returns (s:int)
requires N >= 0
ensures s == N * (N + 1) / 2
{
var n := 0;
s := 0;
while n != N
{
n := n + 1;
s := s + n;
}
}
| method Sum(N:int) returns (s:int)
requires N >= 0
ensures s == N * (N + 1) / 2
{
var n := 0;
s := 0;
while n != N
invariant 0 <= n <= N
invariant s == n * (n + 1) / 2
{
n := n + 1;
s := s + n;
}
}
| Clover_cal_sum.dfy | 20 |
method CanyonSearch(a: array<int>, b: array<int>) returns (d:nat)
requires a.Length !=0 && b.Length!=0
requires forall i,j :: 0<=i<j<a.Length ==> a[i]<=a[j]
requires forall i,j :: 0<=i<j<b.Length ==> b[i]<=b[j]
ensures exists i,j:: 0<=i<a.Length && 0<=j<b.Length && d==if a[i] < b[j] then (b[j]-a[i]) else (a[i]-b[j])
ensures forall i,j:: 0<=i<a.Length && 0<=j<b.Length ==> d<=if a[i] < b[j] then (b[j]-a[i]) else (a[i]-b[j])
{
var m,n:=0,0;
d:=if a[0] < b[0] then (b[0]-a[0]) else (a[0]-b[0]);
while m<a.Length && n<b.Length
{
var t := if a[m] < b[n] then (b[n]-a[m]) else (a[m]-b[n]);
d:=if t<d then t else d;
if
case a[m]<=b[n] =>
m:=m+1;
case b[n]<=a[m] =>
n:=n+1;
}
}
| method CanyonSearch(a: array<int>, b: array<int>) returns (d:nat)
requires a.Length !=0 && b.Length!=0
requires forall i,j :: 0<=i<j<a.Length ==> a[i]<=a[j]
requires forall i,j :: 0<=i<j<b.Length ==> b[i]<=b[j]
ensures exists i,j:: 0<=i<a.Length && 0<=j<b.Length && d==if a[i] < b[j] then (b[j]-a[i]) else (a[i]-b[j])
ensures forall i,j:: 0<=i<a.Length && 0<=j<b.Length ==> d<=if a[i] < b[j] then (b[j]-a[i]) else (a[i]-b[j])
{
var m,n:=0,0;
d:=if a[0] < b[0] then (b[0]-a[0]) else (a[0]-b[0]);
while m<a.Length && n<b.Length
invariant 0<=m<=a.Length && 0<=n<=b.Length
decreases a.Length -m+b.Length-n
invariant exists i,j:: 0<=i<a.Length && 0<=j<b.Length && d==if a[i] < b[j] then (b[j]-a[i]) else (a[i]-b[j])
invariant forall i,j:: 0<=i<a.Length && 0<=j<b.Length ==> d<=(if a[i] < b[j] then (b[j]-a[i]) else (a[i]-b[j]))|| (m<=i&&n<=j)
{
var t := if a[m] < b[n] then (b[n]-a[m]) else (a[m]-b[n]);
d:=if t<d then t else d;
if
case a[m]<=b[n] =>
m:=m+1;
case b[n]<=a[m] =>
n:=n+1;
}
}
| Clover_canyon_search.dfy | 21 |
method copy( src: array<int>, sStart: nat, dest: array<int>, dStart: nat, len: nat) returns (r: array<int>)
requires src.Length >= sStart + len
requires dest.Length >= dStart + len
ensures r.Length == dest.Length
ensures r[..dStart] == dest[..dStart]
ensures r[dStart + len..] == dest[dStart + len..]
ensures r[dStart..len+dStart] == src[sStart..len+sStart]
{
if len == 0 { return dest; }
var i: nat := 0;
r := new int[dest.Length];
while (i < r.Length)
{
r[i] := dest[i];
i := i + 1;
}
i := 0;
while (i < len)
{
r[dStart + i] := src[sStart + i];
i := i + 1;
}
} | method copy( src: array<int>, sStart: nat, dest: array<int>, dStart: nat, len: nat) returns (r: array<int>)
requires src.Length >= sStart + len
requires dest.Length >= dStart + len
ensures r.Length == dest.Length
ensures r[..dStart] == dest[..dStart]
ensures r[dStart + len..] == dest[dStart + len..]
ensures r[dStart..len+dStart] == src[sStart..len+sStart]
{
if len == 0 { return dest; }
var i: nat := 0;
r := new int[dest.Length];
while (i < r.Length)
invariant i <= r.Length
invariant r[..i] == dest[..i]
{
r[i] := dest[i];
i := i + 1;
}
assert r[..]==dest[..];
i := 0;
while (i < len)
invariant i <= len
invariant r[..dStart] == dest[..dStart]
invariant r[(dStart + len)..] == dest[(dStart + len)..]
invariant r[dStart .. dStart + i] == src[sStart .. sStart + i]
{
assert r[(dStart + len)..] == dest[(dStart + len)..];
r[dStart + i] := src[sStart + i];
i := i + 1;
}
} | Clover_copy_part.dfy | 22 |
method CountLessThan(numbers: set<int>, threshold: int) returns (count: int)
ensures count == |set i | i in numbers && i < threshold|
{
count := 0;
var shrink := numbers;
var grow := {};
while |shrink | > 0
{
var i: int :| i in shrink;
shrink := shrink - {i};
var grow' := grow+{i};
grow := grow + {i};
if i < threshold {
count := count + 1;
}
}
}
| method CountLessThan(numbers: set<int>, threshold: int) returns (count: int)
ensures count == |set i | i in numbers && i < threshold|
{
count := 0;
var shrink := numbers;
var grow := {};
while |shrink | > 0
decreases shrink
invariant shrink + grow == numbers
invariant grow !! shrink
invariant count == |set i | i in grow && i < threshold|
{
var i: int :| i in shrink;
shrink := shrink - {i};
var grow' := grow+{i};
assert (set i | i in grow' && i < threshold) ==
(set i | i in grow && i < threshold )+ if i < threshold then {i} else {};
grow := grow + {i};
if i < threshold {
count := count + 1;
}
}
}
| Clover_count_lessthan.dfy | 23 |
method double_array_elements(s: array<int>)
modifies s
ensures forall i :: 0 <= i < s.Length ==> s[i] == 2 * old(s[i])
{
var i:= 0;
while (i < s.Length)
{
s[i] := 2 * s[i];
i := i + 1;
}
} | method double_array_elements(s: array<int>)
modifies s
ensures forall i :: 0 <= i < s.Length ==> s[i] == 2 * old(s[i])
{
var i:= 0;
while (i < s.Length)
invariant 0 <= i <= s.Length
invariant forall x :: i <= x < s.Length ==> s[x] == old(s[x])
invariant forall x :: 0 <= x < i ==> s[x] == 2 * old(s[x])
{
s[i] := 2 * s[i];
i := i + 1;
}
} | Clover_double_array_elements.dfy | 24 |
method FindEvenNumbers (arr: array<int>) returns (evenNumbers: array<int>)
ensures forall x {:trigger (x%2) }:: x in arr[..] && (x%2==0)==> x in evenNumbers[..]
ensures forall x :: x !in arr[..] ==> x !in evenNumbers[..]
ensures forall k :: 0 <= k < evenNumbers.Length ==> evenNumbers[k] % 2 == 0
ensures forall k, l :: 0 <= k < l < evenNumbers.Length ==>
exists n, m :: 0 <= n < m < arr.Length && evenNumbers[k] == arr[n] && evenNumbers[l] == arr[m]
{
var evenList: seq<int> := [];
ghost var indices: seq<int> := [];
for i := 0 to arr.Length
{
if arr[i]%2==0
{
evenList := evenList + [arr[i]];
indices := indices + [i];
}
}
evenNumbers := new int[|evenList|](i requires 0 <= i < |evenList| => evenList[i]);
}
| method FindEvenNumbers (arr: array<int>) returns (evenNumbers: array<int>)
ensures forall x {:trigger (x%2) }:: x in arr[..] && (x%2==0)==> x in evenNumbers[..]
ensures forall x :: x !in arr[..] ==> x !in evenNumbers[..]
ensures forall k :: 0 <= k < evenNumbers.Length ==> evenNumbers[k] % 2 == 0
ensures forall k, l :: 0 <= k < l < evenNumbers.Length ==>
exists n, m :: 0 <= n < m < arr.Length && evenNumbers[k] == arr[n] && evenNumbers[l] == arr[m]
{
var evenList: seq<int> := [];
ghost var indices: seq<int> := [];
for i := 0 to arr.Length
invariant 0 <= i <= arr.Length
invariant 0 <= |evenList| <= i
invariant forall x {:trigger (x%2) }:: (x in arr[..i] && (x%2==0) )==> x in evenList[..]
invariant forall k :: 0 <= k < |evenList| ==> evenList[k] % 2 == 0
invariant forall x :: x !in arr[..i] ==> x !in evenList
invariant |evenList| == |indices|
invariant forall k :: 0 <= k < |indices| ==> indices[k] < i
invariant forall k, l :: 0 <= k < l < |indices| ==> indices[k] < indices[l]
invariant forall k :: 0 <= k < |evenList| ==> 0 <= indices[k] < i <= arr.Length && arr[indices[k]] == evenList[k]
{
if arr[i]%2==0
{
evenList := evenList + [arr[i]];
indices := indices + [i];
}
}
evenNumbers := new int[|evenList|](i requires 0 <= i < |evenList| => evenList[i]);
assert evenList == evenNumbers[..];
}
| Clover_even_list.dfy | 25 |
method Find(a: array<int>, key: int) returns (index: int)
ensures -1<=index<a.Length
ensures index!=-1 ==> a[index]==key && (forall i :: 0 <= i < index ==> a[i] != key)
ensures index == -1 ==> (forall i::0 <= i < a.Length ==> a[i] != key)
{
index := 0;
while index < a.Length
{
if a[index] == key { return; }
index := index + 1;
}
if index >= a.Length {
index := -1;
}
}
| method Find(a: array<int>, key: int) returns (index: int)
ensures -1<=index<a.Length
ensures index!=-1 ==> a[index]==key && (forall i :: 0 <= i < index ==> a[i] != key)
ensures index == -1 ==> (forall i::0 <= i < a.Length ==> a[i] != key)
{
index := 0;
while index < a.Length
invariant 0<=index<=a.Length
invariant (forall i::0 <= i < index==>a[i] != key)
{
if a[index] == key { return; }
index := index + 1;
}
if index >= a.Length {
index := -1;
}
}
| Clover_find.dfy | 26 |
method has_close_elements(numbers: seq<real>, threshold: real) returns (res: bool)
requires threshold >= 0.0
ensures res ==> exists i: int, j: int :: 0 <= i < |numbers| && 0 <= j < |numbers| && i != j && (if numbers[i] - numbers[j] < 0.0 then numbers[j] - numbers[i] else numbers[i] - numbers[j]) < threshold
ensures !res ==> (forall i: int, j: int :: 1 <= i < |numbers| && 0 <= j < i ==> (if numbers[i] - numbers[j] < 0.0 then numbers[j] - numbers[i] else numbers[i] - numbers[j]) >= threshold)
{
res := false;
var idx: int := 0;
while idx < |numbers| && !res
{
var idx2: int := 0;
while idx2 < idx && !res
{
var distance := (if numbers[idx2] - numbers[idx] < 0.0 then numbers[idx] - numbers[idx2] else numbers[idx2] - numbers[idx]);
if distance < threshold {
res := true;
return;
}
idx2 := idx2 + 1;
}
idx := idx + 1;
}
}
| method has_close_elements(numbers: seq<real>, threshold: real) returns (res: bool)
requires threshold >= 0.0
ensures res ==> exists i: int, j: int :: 0 <= i < |numbers| && 0 <= j < |numbers| && i != j && (if numbers[i] - numbers[j] < 0.0 then numbers[j] - numbers[i] else numbers[i] - numbers[j]) < threshold
ensures !res ==> (forall i: int, j: int :: 1 <= i < |numbers| && 0 <= j < i ==> (if numbers[i] - numbers[j] < 0.0 then numbers[j] - numbers[i] else numbers[i] - numbers[j]) >= threshold)
{
res := false;
var idx: int := 0;
while idx < |numbers| && !res
invariant 0 <= idx <= |numbers|
invariant !res
invariant forall i: int, j: int :: 0 <= i < idx && 0 <= j < i ==> (if numbers[i] - numbers[j] < 0.0 then numbers[j] - numbers[i] else numbers[i] - numbers[j]) >= threshold
{
var idx2: int := 0;
while idx2 < idx && !res
invariant 0 <= idx <= |numbers|
invariant 0 <= idx2 <= idx
invariant !res
invariant forall j: int :: 0 <= j < idx2 ==> (if numbers[idx] - numbers[j] < 0.0 then numbers[j] - numbers[idx] else numbers[idx] - numbers[j]) >= threshold
{
var distance := (if numbers[idx2] - numbers[idx] < 0.0 then numbers[idx] - numbers[idx2] else numbers[idx2] - numbers[idx]);
if distance < threshold {
res := true;
return;
}
idx2 := idx2 + 1;
}
idx := idx + 1;
}
}
| Clover_has_close_elements.dfy | 27 |
method insert(line:array<char>, l:int, nl:array<char>, p:int, at:int)
requires 0 <= l+p <= line.Length
requires 0 <= p <= nl.Length
requires 0 <= at <= l
modifies line
ensures forall i :: (0<=i<p) ==> line[at+i] == nl[i]
ensures forall i :: (0<=i<at) ==> line[i] == old(line[i])
ensures forall i :: (at+p<=i<l+p) ==> line[i] == old(line[i-p])
{
ghost var initialLine := line[..];
var i:int := l;
while(i>at)
{
i := i - 1;
line[i+p] := line[i];
}
i := 0;
while(i<p)
{
line[at + i] := nl[i];
i := i + 1;
}
} | method insert(line:array<char>, l:int, nl:array<char>, p:int, at:int)
requires 0 <= l+p <= line.Length
requires 0 <= p <= nl.Length
requires 0 <= at <= l
modifies line
ensures forall i :: (0<=i<p) ==> line[at+i] == nl[i]
ensures forall i :: (0<=i<at) ==> line[i] == old(line[i])
ensures forall i :: (at+p<=i<l+p) ==> line[i] == old(line[i-p])
{
ghost var initialLine := line[..];
var i:int := l;
while(i>at)
invariant line[0..i] == initialLine[0..i]
invariant line[i+p..l+p] == initialLine[i..l]
invariant at<=i<=l
{
i := i - 1;
line[i+p] := line[i];
}
assert line[0..at] == initialLine[0..at];
assert line[at+p..l+p] == initialLine[at..l];
i := 0;
while(i<p)
invariant 0<=i<=p
invariant line[0..at] == initialLine[0..at]
invariant line[at..at+i] == nl[0..i]
invariant line[at+p..l+p] == initialLine[at..l]
{
line[at + i] := nl[i];
i := i + 1;
}
assert line[0..at] == initialLine[0..at];
assert line[at..at+p] == nl[0..p];
assert line[at+p..l+p] == initialLine[at..l];
} | Clover_insert.dfy | 28 |
method SquareRoot(N:nat) returns (r:nat)
ensures r*r <= N < (r+1)*(r+1)
{
r:=0;
while (r+1)*(r+1)<=N
{
r:=r+1;
}
}
| method SquareRoot(N:nat) returns (r:nat)
ensures r*r <= N < (r+1)*(r+1)
{
r:=0;
while (r+1)*(r+1)<=N
invariant r*r<=N
{
r:=r+1;
}
}
| Clover_integer_square_root.dfy | 29 |
method IsPalindrome(x: seq<char>) returns (result: bool)
ensures result <==> (forall i :: 0 <= i < |x| ==> x[i] == x[|x| - i - 1])
{
if |x|==0 {
return true;
}
var i := 0;
var j := |x| - 1;
result := true;
while (i < j)
{
if x[i] != x[j] {
result := false;
return;
}
i := i + 1;
j := j - 1;
}
}
| method IsPalindrome(x: seq<char>) returns (result: bool)
ensures result <==> (forall i :: 0 <= i < |x| ==> x[i] == x[|x| - i - 1])
{
if |x|==0 {
return true;
}
var i := 0;
var j := |x| - 1;
result := true;
while (i < j)
invariant 0<=i<=j+1 && 0<=j < |x|
invariant i+j==|x|-1
invariant (forall k :: 0 <= k < i ==> x[k] == x[|x| - k - 1])
{
if x[i] != x[j] {
result := false;
return;
}
i := i + 1;
j := j - 1;
}
}
| Clover_is_palindrome.dfy | 30 |
method LinearSearch(a: array<int>, e: int) returns (n:int)
ensures 0<=n<=a.Length
ensures n==a.Length || a[n]==e
ensures forall i::0<=i < n ==> e!=a[i]
{
n :=0;
while n!=a.Length
{
if e==a[n]{
return;
}
n:=n+1;
}
}
| method LinearSearch(a: array<int>, e: int) returns (n:int)
ensures 0<=n<=a.Length
ensures n==a.Length || a[n]==e
ensures forall i::0<=i < n ==> e!=a[i]
{
n :=0;
while n!=a.Length
invariant 0<=n<=a.Length
invariant forall i::0<=i<n ==> e!=a[i]
{
if e==a[n]{
return;
}
n:=n+1;
}
}
| Clover_linear_search1.dfy | 31 |
method LinearSearch(a: array<int>, e: int) returns (n:int)
requires exists i::0<=i<a.Length && a[i]==e
ensures 0<=n<a.Length && a[n]==e
ensures forall k :: 0 <= k < n ==> a[k]!=e
{
n :=0;
while n!=a.Length
{
if e==a[n]{
return;
}
n:=n+1;
}
}
| method LinearSearch(a: array<int>, e: int) returns (n:int)
requires exists i::0<=i<a.Length && a[i]==e
ensures 0<=n<a.Length && a[n]==e
ensures forall k :: 0 <= k < n ==> a[k]!=e
{
n :=0;
while n!=a.Length
invariant 0<=n<=a.Length
invariant forall i::0<=i<n ==> e!=a[i]
{
if e==a[n]{
return;
}
n:=n+1;
}
}
| Clover_linear_search2.dfy | 32 |
method LinearSearch3<T>(a: array<T>, P: T -> bool) returns (n: int)
requires exists i :: 0 <= i < a.Length && P(a[i])
ensures 0 <= n < a.Length && P(a[n])
ensures forall k :: 0 <= k < n ==> !P(a[k])
{
n := 0;
while true
{
if P(a[n]) {
return;
}
n := n + 1;
}
}
| method LinearSearch3<T>(a: array<T>, P: T -> bool) returns (n: int)
requires exists i :: 0 <= i < a.Length && P(a[i])
ensures 0 <= n < a.Length && P(a[n])
ensures forall k :: 0 <= k < n ==> !P(a[k])
{
n := 0;
while true
invariant 0 <= n < a.Length
invariant exists i :: n <= i < a.Length && P(a[i])
invariant forall k :: 0 <= k < n ==> !P(a[k])
decreases a.Length - n
{
if P(a[n]) {
return;
}
n := n + 1;
}
}
| Clover_linear_search3.dfy | 33 |
method LongestCommonPrefix(str1: seq<char>, str2: seq<char>) returns (prefix: seq<char>)
ensures |prefix| <= |str1| && prefix == str1[0..|prefix|]&& |prefix| <= |str2| && prefix == str2[0..|prefix|]
ensures |prefix|==|str1| || |prefix|==|str2| || (str1[|prefix|]!=str2[|prefix|])
{
prefix := [];
var minLength := if |str1| <|str2| then |str1| else |str2|;
for idx:= 0 to minLength
{
if str1[idx] != str2[idx] {
return;
}
prefix := prefix + [str1[idx]];
}
}
| method LongestCommonPrefix(str1: seq<char>, str2: seq<char>) returns (prefix: seq<char>)
ensures |prefix| <= |str1| && prefix == str1[0..|prefix|]&& |prefix| <= |str2| && prefix == str2[0..|prefix|]
ensures |prefix|==|str1| || |prefix|==|str2| || (str1[|prefix|]!=str2[|prefix|])
{
prefix := [];
var minLength := if |str1| <|str2| then |str1| else |str2|;
for idx:= 0 to minLength
invariant |prefix|==idx <= minLength<=|str1| && minLength<=|str2|
invariant |prefix| <= |str1| && prefix == str1[0..|prefix|]&& |prefix| <= |str2| && prefix == str2[0..|prefix|]
{
if str1[idx] != str2[idx] {
return;
}
prefix := prefix + [str1[idx]];
}
}
| Clover_longest_prefix.dfy | 34 |
method Match(s: string, p: string) returns (b: bool)
requires |s| == |p|
ensures b <==> forall n :: 0 <= n < |s| ==> s[n] == p[n] || p[n] == '?'
{
var i := 0;
while i < |s|
{
if s[i] != p[i] && p[i] != '?'
{
return false;
}
i := i + 1;
}
return true;
}
| method Match(s: string, p: string) returns (b: bool)
requires |s| == |p|
ensures b <==> forall n :: 0 <= n < |s| ==> s[n] == p[n] || p[n] == '?'
{
var i := 0;
while i < |s|
invariant 0 <= i <= |s|
invariant forall n :: 0 <= n < i ==> s[n] == p[n] || p[n] == '?'
{
if s[i] != p[i] && p[i] != '?'
{
return false;
}
i := i + 1;
}
return true;
}
| Clover_match.dfy | 35 |
method maxArray(a: array<int>) returns (m: int)
requires a.Length >= 1
ensures forall k :: 0 <= k < a.Length ==> m >= a[k]
ensures exists k :: 0 <= k < a.Length && m == a[k]
{
m := a[0];
var index := 1;
while (index < a.Length)
{
m := if m>a[index] then m else a[index];
index := index + 1;
}
}
| method maxArray(a: array<int>) returns (m: int)
requires a.Length >= 1
ensures forall k :: 0 <= k < a.Length ==> m >= a[k]
ensures exists k :: 0 <= k < a.Length && m == a[k]
{
m := a[0];
var index := 1;
while (index < a.Length)
invariant 0 <= index <= a.Length
invariant forall k :: 0 <= k < index ==> m >= a[k]
invariant exists k :: 0 <= k < index && m == a[k]
decreases a.Length - index
{
m := if m>a[index] then m else a[index];
index := index + 1;
}
}
| Clover_max_array.dfy | 36 |
method minArray(a: array<int>) returns (r:int)
requires a.Length > 0
ensures forall i :: 0 <= i < a.Length ==> r <= a[i]
ensures exists i :: 0 <= i < a.Length && r == a[i]
{
r:=a[0];
var i:=1;
while i<a.Length
{
if r>a[i]{
r:=a[i];
}
i:=i+1;
}
}
| method minArray(a: array<int>) returns (r:int)
requires a.Length > 0
ensures forall i :: 0 <= i < a.Length ==> r <= a[i]
ensures exists i :: 0 <= i < a.Length && r == a[i]
{
r:=a[0];
var i:=1;
while i<a.Length
invariant 0 <= i <= a.Length
invariant forall x :: 0 <= x < i ==> r <= a[x]
invariant exists x :: 0 <= x < i && r == a[x]
{
if r>a[i]{
r:=a[i];
}
i:=i+1;
}
}
| Clover_min_array.dfy | 37 |
method onlineMax(a: array<int>, x: int) returns (ghost m:int, p:int)
requires 1<=x<a.Length
requires a.Length!=0
ensures x<=p<a.Length
ensures forall i::0<=i<x==> a[i]<=m
ensures exists i::0<=i<x && a[i]==m
ensures x<=p<a.Length-1 ==> (forall i::0<=i<p ==> a[i]<a[p])
ensures (forall i::x<=i<a.Length && a[i]<=m) ==> p==a.Length-1
{
p:= 0;
var best := a[0];
var i:=1;
while i<x
{
if a[i]>best{
best:=a[i];
}
i:=i+1;
}
m:=best;
i:=x;
while i<a.Length
{
if a[i]>best{
p:=i;
return;
}
i:=i+1;
}
p:=a.Length-1;
}
| method onlineMax(a: array<int>, x: int) returns (ghost m:int, p:int)
requires 1<=x<a.Length
requires a.Length!=0
ensures x<=p<a.Length
ensures forall i::0<=i<x==> a[i]<=m
ensures exists i::0<=i<x && a[i]==m
ensures x<=p<a.Length-1 ==> (forall i::0<=i<p ==> a[i]<a[p])
ensures (forall i::x<=i<a.Length && a[i]<=m) ==> p==a.Length-1
{
p:= 0;
var best := a[0];
var i:=1;
while i<x
invariant 0<=i<=x
invariant forall j::0<=j<i==> a[j]<=best
invariant exists j::0<=j<i && a[j]==best
{
if a[i]>best{
best:=a[i];
}
i:=i+1;
}
m:=best;
i:=x;
while i<a.Length
invariant x<=i<=a.Length
invariant forall j::x<=j<i ==> a[j]<=m
{
if a[i]>best{
p:=i;
return;
}
i:=i+1;
}
p:=a.Length-1;
}
| Clover_online_max.dfy | 38 |
method only_once<T(==)>(a: array<T>, key: T) returns (b:bool)
ensures (multiset(a[..])[key] ==1 ) <==> b
{
var i := 0;
b := false;
var keyCount := 0;
while i < a.Length
{
if (a[i] == key)
{
keyCount := keyCount + 1;
}
if (keyCount == 1)
{ b := true; }
else
{ b := false; }
i := i + 1;
}
}
| method only_once<T(==)>(a: array<T>, key: T) returns (b:bool)
ensures (multiset(a[..])[key] ==1 ) <==> b
{
var i := 0;
b := false;
var keyCount := 0;
while i < a.Length
invariant 0 <= i <= a.Length
invariant multiset(a[..i])[key] == keyCount
invariant b <==> (keyCount == 1)
{
if (a[i] == key)
{
keyCount := keyCount + 1;
}
if (keyCount == 1)
{ b := true; }
else
{ b := false; }
i := i + 1;
}
assert a[..a.Length] == a[..];
}
| Clover_only_once.dfy | 39 |
method Quotient(x: nat, y:nat) returns (r:int, q:int)
requires y != 0
ensures q * y + r == x && 0 <= r < y && 0 <= q
{
r:=x;
q:=0;
while y<=r
{
r:=r-y;
q:=q+1;
}
}
| method Quotient(x: nat, y:nat) returns (r:int, q:int)
requires y != 0
ensures q * y + r == x && 0 <= r < y && 0 <= q
{
r:=x;
q:=0;
while y<=r
invariant q*y+r==x && r>=0
decreases r
{
r:=r-y;
q:=q+1;
}
}
| Clover_quotient.dfy | 40 |
method remove_front(a:array<int>) returns (c:array<int>)
requires a.Length>0
ensures a[1..] == c[..]
{
c := new int[a.Length-1];
var i:= 1;
while (i < a.Length)
{
c[i-1] := a[i];
i:=i+1;
}
}
| method remove_front(a:array<int>) returns (c:array<int>)
requires a.Length>0
ensures a[1..] == c[..]
{
c := new int[a.Length-1];
var i:= 1;
while (i < a.Length)
invariant 1 <= i <= a.Length
invariant forall ii::1<=ii<i ==> c[ii-1]==a[ii]
{
c[i-1] := a[i];
i:=i+1;
}
}
| Clover_remove_front.dfy | 41 |
method replace(arr: array<int>, k: int)
modifies arr
ensures forall i :: 0 <= i < arr.Length ==> old(arr[i]) > k ==> arr[i] == -1
ensures forall i :: 0 <= i < arr.Length ==> old(arr[i]) <= k ==> arr[i] == old(arr[i])
{
var i := 0;
while i < arr.Length
{
if arr[i] > k {
arr[i] := -1;
}
i := i + 1;
}
}
| method replace(arr: array<int>, k: int)
modifies arr
ensures forall i :: 0 <= i < arr.Length ==> old(arr[i]) > k ==> arr[i] == -1
ensures forall i :: 0 <= i < arr.Length ==> old(arr[i]) <= k ==> arr[i] == old(arr[i])
{
var i := 0;
while i < arr.Length
decreases arr.Length - i
invariant 0 <= i <= arr.Length
invariant forall j :: 0 <= j < i ==> old(arr[j]) > k ==> arr[j] == -1
invariant forall j :: 0 <= j < i ==> old(arr[j]) <= k ==> arr[j] == old(arr[j])
invariant forall j :: i <= j < arr.Length ==> old(arr[j]) == arr[j]
{
if arr[i] > k {
arr[i] := -1;
}
i := i + 1;
}
}
| Clover_replace.dfy | 42 |
method reverse(a: array<int>)
modifies a
ensures forall i :: 0 <= i < a.Length ==> a[i] == old(a[a.Length - 1 - i])
{
var i := 0;
while i <a.Length / 2
{
a[i], a[a.Length-1-i] := a[a.Length-1-i], a[i];
i := i + 1;
}
}
| method reverse(a: array<int>)
modifies a
ensures forall i :: 0 <= i < a.Length ==> a[i] == old(a[a.Length - 1 - i])
{
var i := 0;
while i <a.Length / 2
invariant 0 <= i <= a.Length/2
invariant forall k :: 0 <= k < i || a.Length-1-i < k <= a.Length-1 ==> a[k] == old(a[a.Length-1-k])
invariant forall k :: i <= k <= a.Length-1-i ==> a[k] == old(a[k])
{
a[i], a[a.Length-1-i] := a[a.Length-1-i], a[i];
i := i + 1;
}
}
| Clover_reverse.dfy | 43 |
method rotate(a: array<int>, offset:int) returns (b: array<int> )
requires 0<=offset
ensures b.Length==a.Length
ensures forall i::0<=i<a.Length ==> b[i]==a[(i+offset)%a.Length]
{
b:= new int[a.Length];
var i:=0;
while i<a.Length
{
b[i]:=a[(i+offset)%a.Length];
i:=i+1;
}
} | method rotate(a: array<int>, offset:int) returns (b: array<int> )
requires 0<=offset
ensures b.Length==a.Length
ensures forall i::0<=i<a.Length ==> b[i]==a[(i+offset)%a.Length]
{
b:= new int[a.Length];
var i:=0;
while i<a.Length
invariant 0<=i<=a.Length
invariant forall j ::0<=j<i ==> b[j]==a[(j+offset)%a.Length]
{
b[i]:=a[(i+offset)%a.Length];
i:=i+1;
}
} | Clover_rotate.dfy | 44 |
method SelectionSort(a: array<int>)
modifies a
ensures forall i,j :: 0 <= i < j < a.Length ==> a[i] <= a[j]
ensures multiset(a[..]) == old(multiset(a[..]))
{
var n:= 0;
while n != a.Length
{
var mindex, m := n, n+1;
while m != a.Length
{
if a[m] < a[mindex] {
mindex := m;
}
m := m+1;
}
a[n], a[mindex] := a[mindex], a[n];
n := n+1;
}
}
| method SelectionSort(a: array<int>)
modifies a
ensures forall i,j :: 0 <= i < j < a.Length ==> a[i] <= a[j]
ensures multiset(a[..]) == old(multiset(a[..]))
{
var n:= 0;
while n != a.Length
invariant 0 <= n <= a.Length
invariant forall i, j :: 0 <= i < n <= j < a.Length ==> a[i] <= a[j]
invariant forall i,j :: 0 <= i < j < n ==> a[i] <= a[j]
invariant multiset(a[..]) == old(multiset(a[..]))
{
var mindex, m := n, n+1;
while m != a.Length
invariant n <= mindex < m <= a.Length
invariant forall i :: n <= i < m ==> a[mindex] <= a[i]
{
if a[m] < a[mindex] {
mindex := m;
}
m := m+1;
}
a[n], a[mindex] := a[mindex], a[n];
n := n+1;
}
}
| Clover_selectionsort.dfy | 45 |
method SetToSeq<T>(s: set<T>) returns (xs: seq<T>)
ensures multiset(s) == multiset(xs)
{
xs := [];
var left: set<T> := s;
while left != {}
{
var x :| x in left;
left := left - {x};
xs := xs + [x];
}
}
| method SetToSeq<T>(s: set<T>) returns (xs: seq<T>)
ensures multiset(s) == multiset(xs)
{
xs := [];
var left: set<T> := s;
while left != {}
invariant multiset(left) + multiset(xs) == multiset(s)
{
var x :| x in left;
left := left - {x};
xs := xs + [x];
}
}
| Clover_set_to_seq.dfy | 46 |
method SlopeSearch(a: array2<int>, key: int) returns (m:int, n:int)
requires forall i,j,j'::0<=i<a.Length0 && 0<=j<j'<a.Length1 ==> a[i,j]<=a[i,j']
requires forall i,i',j::0<=i<i'<a.Length0 && 0<=j<a.Length1 ==> a[i,j]<=a[i',j]
requires exists i,j :: 0<=i<a.Length0 && 0<=j<a.Length1 && a[i,j]==key
ensures 0<=m<a.Length0 && 0<=n<a.Length1
ensures a[m,n]==key
{
m,n:=0, a.Length1-1;
while a[m,n] !=key
{
if a[m,n] < key {
m:=m+1;
}else{
n:=n-1;
}
}
}
| method SlopeSearch(a: array2<int>, key: int) returns (m:int, n:int)
requires forall i,j,j'::0<=i<a.Length0 && 0<=j<j'<a.Length1 ==> a[i,j]<=a[i,j']
requires forall i,i',j::0<=i<i'<a.Length0 && 0<=j<a.Length1 ==> a[i,j]<=a[i',j]
requires exists i,j :: 0<=i<a.Length0 && 0<=j<a.Length1 && a[i,j]==key
ensures 0<=m<a.Length0 && 0<=n<a.Length1
ensures a[m,n]==key
{
m,n:=0, a.Length1-1;
while a[m,n] !=key
invariant 0<=m<a.Length0 && 0<=n<a.Length1
invariant exists i,j :: m<=i<a.Length0 && 0<=j<=n && a[i,j]==key
decreases a.Length0-m+n
{
if a[m,n] < key {
m:=m+1;
}else{
n:=n-1;
}
}
}
| Clover_slope_search.dfy | 47 |
method twoSum(nums: array<int>, target: int) returns (i: int, j: int)
requires nums.Length > 1
requires exists i,j::0 <= i < j < nums.Length && nums[i] + nums[j] == target
ensures 0 <= i < j < nums.Length && nums[i] + nums[j] == target
ensures forall ii,jj:: (0 <= ii < i && ii < jj < nums.Length) ==> nums[ii] + nums[jj] != target
ensures forall jj:: i < jj < j ==> nums[i] + nums[jj] != target
{
var n := nums.Length;
i := 0;
j := 1;
while i < n - 1
{
j := i + 1;
while j < n
{
if nums[i] + nums[j] == target {
return;
}
j := j + 1;
}
i := i + 1;
}
}
| method twoSum(nums: array<int>, target: int) returns (i: int, j: int)
requires nums.Length > 1
requires exists i,j::0 <= i < j < nums.Length && nums[i] + nums[j] == target
ensures 0 <= i < j < nums.Length && nums[i] + nums[j] == target
ensures forall ii,jj:: (0 <= ii < i && ii < jj < nums.Length) ==> nums[ii] + nums[jj] != target
ensures forall jj:: i < jj < j ==> nums[i] + nums[jj] != target
{
var n := nums.Length;
i := 0;
j := 1;
while i < n - 1
invariant 0 <= i < j <= n
invariant forall ii, jj :: 0 <= ii < i && ii < jj < n ==> nums[ii] + nums[jj] != target
{
j := i + 1;
while j < n
invariant 0 <= i < j <= n
invariant forall jj :: i < jj < j ==> nums[i] + nums[jj] != target
{
if nums[i] + nums[j] == target {
return;
}
j := j + 1;
}
i := i + 1;
}
}
| Clover_two_sum.dfy | 48 |
//Method barrier below receives an array and an integer p
//and returns a boolean b which is true if and only if
//all the positions to the left of p and including also position p contain elements
//that are strictly smaller than all the elements contained in the positions to the right of p
//Examples:
// If v=[7,2,5,8] and p=0 or p=1 then the method must return false,
// but for p=2 the method should return true
//1.Specify the method
//2.Implement an O(v.size()) method
//3.Verify the method
method barrier(v:array<int>,p:int) returns (b:bool)
//Give the precondition
//Give the postcondition
//{Implement and verify}
requires v.Length > 0
requires 0<=p<v.Length
ensures b==forall k,l::0<=k<=p && p<l<v.Length ==> v[k]<v[l]
{
var i:=1;
var max:=0;
while(i<=p)
{
if(v[i]>v[max]){
max:=i;
}
i:=i+1;
}
while(i<v.Length && v[i]>v[max])
{
i:=i+1;
}
b:=i==v.Length;
}
|
//Method barrier below receives an array and an integer p
//and returns a boolean b which is true if and only if
//all the positions to the left of p and including also position p contain elements
//that are strictly smaller than all the elements contained in the positions to the right of p
//Examples:
// If v=[7,2,5,8] and p=0 or p=1 then the method must return false,
// but for p=2 the method should return true
//1.Specify the method
//2.Implement an O(v.size()) method
//3.Verify the method
method barrier(v:array<int>,p:int) returns (b:bool)
//Give the precondition
//Give the postcondition
//{Implement and verify}
requires v.Length > 0
requires 0<=p<v.Length
ensures b==forall k,l::0<=k<=p && p<l<v.Length ==> v[k]<v[l]
{
var i:=1;
var max:=0;
while(i<=p)
decreases p-i
invariant 0<=i<=p+1
invariant 0<=max<i
invariant forall k::0<=k<i ==> v[max] >= v[k]
{
if(v[i]>v[max]){
max:=i;
}
i:=i+1;
}
while(i<v.Length && v[i]>v[max])
decreases v.Length - i
invariant 0<=i<=v.Length
invariant forall k::0<=k<=p ==> v[k]<=v[max]
invariant forall k::p<k<i ==> v[k] > v[max]
{
i:=i+1;
}
b:=i==v.Length;
}
| Dafny-Exercises_tmp_tmpjm75muf__Session10Exercises_ExerciseBarrier.dfy | 49 |
predicate positive(s:seq<int>)
{forall u::0<=u<|s| ==> s[u]>=0}
method mpositive(v:array<int>) returns (b:bool)
ensures b==positive(v[0..v.Length])
{
var i:=0;
//1. assert positive(v[..0])
while i<v.Length && v[i]>=0
{
//2. assert 0<=i<v.Length && positive(v[..i]);
i:=i+1;
//2. assert 0<=i<v.Length && positive(v[..i]);
}
//3. assert i==v.Length ==> positive(v[..]);
//3. assert i<v.Length => v[i]<0;
b := i==v.Length;
}
method mpositive3(v:array<int>) returns (b:bool)
ensures b==positive(v[0..v.Length])
{
var i:=0; b:=true;
while(i<v.Length && b)
{
b:=v[i]>=0;
i:=i+1;
}
}
method mpositive4(v:array<int>) returns (b:bool)
ensures b==positive(v[0..v.Length])
{
var i:=0; b:=true;
while(i<v.Length && b)
{
b:=v[i]>=0;
i:=i+1;
}
}
method mpositivertl(v:array<int>) returns (b:bool)
ensures b==positive(v[0..v.Length])
{
var i:=v.Length-1;
while(i>=0 && v[i]>=0)
{
i:=i-1;
}
b:= i==-1;
}
| predicate positive(s:seq<int>)
{forall u::0<=u<|s| ==> s[u]>=0}
method mpositive(v:array<int>) returns (b:bool)
ensures b==positive(v[0..v.Length])
{
var i:=0;
//1. assert positive(v[..0])
while i<v.Length && v[i]>=0
decreases v.Length - i
invariant 0<=i<=v.Length
invariant positive(v[..i])
{
//2. assert 0<=i<v.Length && positive(v[..i]);
i:=i+1;
//2. assert 0<=i<v.Length && positive(v[..i]);
}
//3. assert i==v.Length ==> positive(v[..]);
//3. assert i<v.Length => v[i]<0;
b := i==v.Length;
}
method mpositive3(v:array<int>) returns (b:bool)
ensures b==positive(v[0..v.Length])
{
var i:=0; b:=true;
while(i<v.Length && b)
decreases v.Length - i
invariant 0 <= i <= v.Length
invariant b==positive(v[0..i])
invariant !b ==> !positive(v[0..v.Length])
{
b:=v[i]>=0;
i:=i+1;
}
}
method mpositive4(v:array<int>) returns (b:bool)
ensures b==positive(v[0..v.Length])
{
var i:=0; b:=true;
while(i<v.Length && b)
decreases v.Length - i
invariant 0 <= i <= v.Length
invariant b==positive(v[0..i])
invariant !b ==> !positive(v[0..v.Length])
{
b:=v[i]>=0;
i:=i+1;
}
}
method mpositivertl(v:array<int>) returns (b:bool)
ensures b==positive(v[0..v.Length])
{
var i:=v.Length-1;
while(i>=0 && v[i]>=0)
decreases i
invariant -1 <= i < v.Length
invariant positive(v[i+1..])
{
i:=i-1;
}
b:= i==-1;
}
| Dafny-Exercises_tmp_tmpjm75muf__Session2Exercises_ExercisePositive.dfy | 50 |
method mroot1(n:int) returns (r:int) //Cost O(root n)
requires n>=0
ensures r>=0 && r*r <= n <(r+1)*(r+1)
{
r:=0;
while (r+1)*(r+1) <=n
{
r:=r+1;
}
}
method mroot2(n:int) returns (r:int) //Cost O(n)
requires n>=0
ensures r>=0 && r*r <= n <(r+1)*(r+1)
{
r:=n;
while n<r*r
{
r:=r-1;
}
}
method mroot3(n:int) returns (r:int) //Cost O(log n)
requires n>=0
ensures r>=0 && r*r <= n <(r+1)*(r+1)
{ var y:int;
var h:int;
r:=0;
y:=n+1;
//Search in interval [0,n+1)
while (y!=r+1) //[r,y]
{
h:=(r+y)/2;
if (h*h<=n)
{r:=h;}
else
{y:=h;}
}
}
| method mroot1(n:int) returns (r:int) //Cost O(root n)
requires n>=0
ensures r>=0 && r*r <= n <(r+1)*(r+1)
{
r:=0;
while (r+1)*(r+1) <=n
invariant r>=0 && r*r <=n
decreases n-r*r
{
r:=r+1;
}
}
method mroot2(n:int) returns (r:int) //Cost O(n)
requires n>=0
ensures r>=0 && r*r <= n <(r+1)*(r+1)
{
r:=n;
while n<r*r
invariant 0<=r<=n && n<(r+1)*(r+1)//write the invariant
invariant r*r<=n ==> n<(r+1)*(r+1)
decreases r//write the bound
{
r:=r-1;
}
}
method mroot3(n:int) returns (r:int) //Cost O(log n)
requires n>=0
ensures r>=0 && r*r <= n <(r+1)*(r+1)
{ var y:int;
var h:int;
r:=0;
y:=n+1;
//Search in interval [0,n+1)
while (y!=r+1) //[r,y]
invariant r>=0 && r*r<=n<y*y && y>=r+1// write the invariant
decreases y-r//write the bound
{
h:=(r+y)/2;
if (h*h<=n)
{r:=h;}
else
{y:=h;}
}
}
| Dafny-Exercises_tmp_tmpjm75muf__Session2Exercises_ExerciseSquare_root.dfy | 51 |
//Algorithm 1: From left to right return the first
method mmaximum1(v:array<int>) returns (i:int)
requires v.Length>0
ensures 0<=i<v.Length
ensures forall k:: 0<=k<v.Length ==> v[i]>=v[k]
{
var j:=1; i:=0;
while(j<v.Length)
{
if(v[j] > v[i]){i:=j;}
j:=j+1;
}
}
//Algorithm 2: From right to left return the last
method mmaximum2(v:array<int>) returns (i:int)
requires v.Length>0
ensures 0<=i<v.Length
ensures forall k:: 0<=k<v.Length ==> v[i]>=v[k]
{
var j:=v.Length-2; i:=v.Length - 1;
while(j>=0)
{
if(v[j] > v[i]){i:=j;}
j:=j-1;
}
}
method mfirstMaximum(v:array<int>) returns (i:int)
requires v.Length>0
ensures 0<=i<v.Length
ensures forall k:: 0<=k<v.Length ==> v[i]>=v[k]
ensures forall l:: 0<=l<i ==> v[i]>v[l]
//Algorithm: from left to right
{
var j:=1; i:=0;
while(j<v.Length)
{
if(v[j] > v[i]){i:=j;}
j:=j+1;
}
}
method mlastMaximum(v:array<int>) returns (i:int)
requires v.Length>0
ensures 0<=i<v.Length
ensures forall k:: 0<=k<v.Length ==> v[i]>=v[k]
ensures forall l:: i<l<v.Length ==> v[i]>v[l]
{
var j:=v.Length-2;
i := v.Length-1;
while(j>=0)
{
if(v[j] > v[i]){i:=j;}
j:=j-1;
}
}
//Algorithm : from left to right
//Algorithm : from right to left
method mmaxvalue1(v:array<int>) returns (m:int)
requires v.Length>0
ensures m in v[..]
ensures forall k::0<=k<v.Length ==> m>=v[k]
{
var i:=mmaximum1(v);
m:=v[i];
}
method mmaxvalue2(v:array<int>) returns (m:int)
requires v.Length>0
ensures m in v[..]
ensures forall k::0<=k<v.Length ==> m>=v[k]
{
var i:=mmaximum2(v);
m:=v[i];
}
| //Algorithm 1: From left to right return the first
method mmaximum1(v:array<int>) returns (i:int)
requires v.Length>0
ensures 0<=i<v.Length
ensures forall k:: 0<=k<v.Length ==> v[i]>=v[k]
{
var j:=1; i:=0;
while(j<v.Length)
decreases v.Length - j
invariant 0<=j<=v.Length
invariant 0<=i<j
invariant forall k:: 0<=k<j ==> v[i] >= v[k]
{
if(v[j] > v[i]){i:=j;}
j:=j+1;
}
}
//Algorithm 2: From right to left return the last
method mmaximum2(v:array<int>) returns (i:int)
requires v.Length>0
ensures 0<=i<v.Length
ensures forall k:: 0<=k<v.Length ==> v[i]>=v[k]
{
var j:=v.Length-2; i:=v.Length - 1;
while(j>=0)
decreases j
invariant 0<=i<v.Length
invariant -1<=j<v.Length-1
invariant forall k :: v.Length>k>j ==> v[k]<=v[i]
{
if(v[j] > v[i]){i:=j;}
j:=j-1;
}
}
method mfirstMaximum(v:array<int>) returns (i:int)
requires v.Length>0
ensures 0<=i<v.Length
ensures forall k:: 0<=k<v.Length ==> v[i]>=v[k]
ensures forall l:: 0<=l<i ==> v[i]>v[l]
//Algorithm: from left to right
{
var j:=1; i:=0;
while(j<v.Length)
decreases v.Length - j
invariant 0<=j<=v.Length
invariant 0<=i<j
invariant forall k:: 0<=k<j ==> v[i] >= v[k]
invariant forall k:: 0<=k<i ==> v[i] > v[k]
{
if(v[j] > v[i]){i:=j;}
j:=j+1;
}
}
method mlastMaximum(v:array<int>) returns (i:int)
requires v.Length>0
ensures 0<=i<v.Length
ensures forall k:: 0<=k<v.Length ==> v[i]>=v[k]
ensures forall l:: i<l<v.Length ==> v[i]>v[l]
{
var j:=v.Length-2;
i := v.Length-1;
while(j>=0)
decreases j
invariant -1<=j<v.Length-1
invariant 0<=i<v.Length
invariant forall k :: v.Length>k>j ==> v[k]<=v[i]
invariant forall k :: v.Length>k>i ==> v[k]<v[i]
{
if(v[j] > v[i]){i:=j;}
j:=j-1;
}
}
//Algorithm : from left to right
//Algorithm : from right to left
method mmaxvalue1(v:array<int>) returns (m:int)
requires v.Length>0
ensures m in v[..]
ensures forall k::0<=k<v.Length ==> m>=v[k]
{
var i:=mmaximum1(v);
m:=v[i];
}
method mmaxvalue2(v:array<int>) returns (m:int)
requires v.Length>0
ensures m in v[..]
ensures forall k::0<=k<v.Length ==> m>=v[k]
{
var i:=mmaximum2(v);
m:=v[i];
}
| Dafny-Exercises_tmp_tmpjm75muf__Session3Exercises_ExerciseMaximum.dfy | 52 |
predicate allEqual(s:seq<int>)
{forall i,j::0<=i<|s| && 0<=j<|s| ==> s[i]==s[j] }
//{forall i,j::0<=i<=j<|s| ==> s[i]==s[j] }
//{forall i::0<i<|s| ==> s[i-1]==s[i]}
//{forall i::0<=i<|s|-1 ==> s[i]==s[i+1]}
//Ordered indexes
lemma equivalenceNoOrder(s:seq<int>)
ensures allEqual(s) <==> forall i,j::0<=i<=j<|s| ==> s[i]==s[j]
{}
//All equal to first
lemma equivalenceEqualtoFirst(s:seq<int>)
requires s!=[]
ensures allEqual(s) <==> (forall i::0<=i<|s| ==> s[0]==s[i])
{}
lemma equivalenceContiguous(s:seq<int>)
ensures (allEqual(s) ==> forall i::0<=i<|s|-1 ==> s[i]==s[i+1])
ensures (allEqual(s) <== forall i::0<=i<|s|-1 ==> s[i]==s[i+1])
{
if(|s|==0 || |s|==1){
}
else{
calc {
forall i::0<=i<|s|-1 ==> s[i]==s[i+1];
==>
{
equivalenceContiguous(s[..|s|-1]);
}
allEqual(s);
}
}
}
method mallEqual1(v:array<int>) returns (b:bool)
ensures b==allEqual(v[0..v.Length])
{
var i := 0;
b := true;
while (i < v.Length && b)
{
b:=(v[i]==v[0]);
i := i+1;
}
}
method mallEqual2(v:array<int>) returns (b:bool)
ensures b==allEqual(v[0..v.Length])
{
var i:int;
b:=true;
i:=0;
while (i < v.Length && v[i] == v[0])
{
i:=i+1;
}
b:=(i==v.Length);
}
method mallEqual3(v:array<int>) returns (b:bool)
ensures b==allEqual(v[0..v.Length])
{
equivalenceContiguous(v[..]);
var i:int;
b:=true;
if (v.Length >0){
i:=0;
while (i<v.Length-1 && v[i]==v[i+1])
{
i:=i+1;
}
b:=(i==v.Length-1);
}
}
method mallEqual4(v:array<int>) returns (b:bool)
ensures b==allEqual(v[0..v.Length])
{
var i:int;
b:=true;
if (v.Length>0){
i:=0;
while (i < v.Length-1 && b)
{
b:=(v[i]==v[i+1]);
i:=i+1;
}
}
}
method mallEqual5(v:array<int>) returns (b:bool)
ensures b==allEqual(v[0..v.Length])
{
var i := 0;
b := true;
while (i < v.Length && b)
{
if (v[i] != v[0]) { b := false; }
else { i := i+1;}
}
}
| predicate allEqual(s:seq<int>)
{forall i,j::0<=i<|s| && 0<=j<|s| ==> s[i]==s[j] }
//{forall i,j::0<=i<=j<|s| ==> s[i]==s[j] }
//{forall i::0<i<|s| ==> s[i-1]==s[i]}
//{forall i::0<=i<|s|-1 ==> s[i]==s[i+1]}
//Ordered indexes
lemma equivalenceNoOrder(s:seq<int>)
ensures allEqual(s) <==> forall i,j::0<=i<=j<|s| ==> s[i]==s[j]
{}
//All equal to first
lemma equivalenceEqualtoFirst(s:seq<int>)
requires s!=[]
ensures allEqual(s) <==> (forall i::0<=i<|s| ==> s[0]==s[i])
{}
lemma equivalenceContiguous(s:seq<int>)
ensures (allEqual(s) ==> forall i::0<=i<|s|-1 ==> s[i]==s[i+1])
ensures (allEqual(s) <== forall i::0<=i<|s|-1 ==> s[i]==s[i+1])
{
assert allEqual(s) ==> forall i::0<=i<|s|-1 ==> s[i]==s[i+1];
if(|s|==0 || |s|==1){
}
else{
calc {
forall i::0<=i<|s|-1 ==> s[i]==s[i+1];
==>
{
equivalenceContiguous(s[..|s|-1]);
assert s[|s|-2] == s[|s|-1];
}
allEqual(s);
}
}
}
method mallEqual1(v:array<int>) returns (b:bool)
ensures b==allEqual(v[0..v.Length])
{
var i := 0;
b := true;
while (i < v.Length && b)
invariant 0 <= i <= v.Length
invariant b==allEqual(v[..i])
decreases v.Length - i
{
b:=(v[i]==v[0]);
i := i+1;
}
}
method mallEqual2(v:array<int>) returns (b:bool)
ensures b==allEqual(v[0..v.Length])
{
var i:int;
b:=true;
i:=0;
while (i < v.Length && v[i] == v[0])
invariant 0 <= i <= v.Length
invariant forall k:: 0 <= k < i ==> v[k] == v[0]
decreases v.Length - i
{
i:=i+1;
}
b:=(i==v.Length);
}
method mallEqual3(v:array<int>) returns (b:bool)
ensures b==allEqual(v[0..v.Length])
{
equivalenceContiguous(v[..]);
var i:int;
b:=true;
if (v.Length >0){
i:=0;
while (i<v.Length-1 && v[i]==v[i+1])
invariant 0<=i<=v.Length -1
invariant b==allEqual(v[..i+1])
decreases v.Length - i
{
i:=i+1;
}
b:=(i==v.Length-1);
}
}
method mallEqual4(v:array<int>) returns (b:bool)
ensures b==allEqual(v[0..v.Length])
{
var i:int;
b:=true;
if (v.Length>0){
i:=0;
while (i < v.Length-1 && b)
invariant 0 <= i < v.Length
invariant b==allEqual(v[..i+1])
decreases v.Length - i
{
b:=(v[i]==v[i+1]);
i:=i+1;
}
}
}
method mallEqual5(v:array<int>) returns (b:bool)
ensures b==allEqual(v[0..v.Length])
{
var i := 0;
b := true;
while (i < v.Length && b)
invariant 0<=i<=v.Length//
invariant b ==> forall k::0<=k<i ==> v[k] == v[0]
invariant !b ==> exists k:: 0<=k<v.Length && v[k]!=v[0]
decreases v.Length - i - (if b then 0 else 1)//
{
if (v[i] != v[0]) { b := false; }
else { i := i+1;}
}
}
| Dafny-Exercises_tmp_tmpjm75muf__Session4Exercises_ExerciseAllEqual.dfy | 53 |
predicate strictSorted(s : seq<int>) {
forall u, w :: 0 <= u < w < |s| ==> s[u] < s[w]
}
method mcontained(v:array<int>,w:array<int>,n:int,m:int) returns (b:bool)
//Specify and implement an O(m+n) algorithm that returns b
//v and w are strictly increasing ordered arrays
//b is true iff the first n elements of v are contained in the first m elements of w
requires n<=m && n>=0
requires strictSorted(v[..])
requires strictSorted(w[..])
requires v.Length >= n && w.Length >= m
ensures b==forall k:: 0<= k< n ==> v[k] in w[..m]//exists j :: 0 <= j < m && v[k] == w[j]
{
var i:=0;
var j:=0;
while(i<n && j<m && (v[i] >= w[j])) //&& b)
{
if(v[i] == w[j]){
i:=i+1;
}
j:=j+1;
}
b := i==n;
}
|
predicate strictSorted(s : seq<int>) {
forall u, w :: 0 <= u < w < |s| ==> s[u] < s[w]
}
method mcontained(v:array<int>,w:array<int>,n:int,m:int) returns (b:bool)
//Specify and implement an O(m+n) algorithm that returns b
//v and w are strictly increasing ordered arrays
//b is true iff the first n elements of v are contained in the first m elements of w
requires n<=m && n>=0
requires strictSorted(v[..])
requires strictSorted(w[..])
requires v.Length >= n && w.Length >= m
ensures b==forall k:: 0<= k< n ==> v[k] in w[..m]//exists j :: 0 <= j < m && v[k] == w[j]
{
var i:=0;
var j:=0;
while(i<n && j<m && (v[i] >= w[j])) //&& b)
invariant 0<=i<=n
invariant 0<=j<=m
invariant strictSorted(v[..])
invariant strictSorted(w[..])
invariant forall k::0<=k<i ==> v[k] in w[..j]
invariant i<n ==> !(v[i] in w[..j])
decreases w.Length-j
decreases v.Length-i
{
if(v[i] == w[j]){
i:=i+1;
}
j:=j+1;
}
assert i<n ==> !(v[i] in w[..m]);
b := i==n;
}
| Dafny-Exercises_tmp_tmpjm75muf__Session4Exercises_ExerciseContained.dfy | 54 |
predicate positive(s:seq<int>)
{forall u::0<=u<|s| ==> s[u]>=0}
method mfirstNegative(v:array<int>) returns (b:bool, i:int)
ensures b <==> exists k::0<=k<v.Length && v[k]<0
ensures b ==> 0<=i<v.Length && v[i]<0 && positive(v[0..i])
{
i:=0;
b:=false;
while (i<v.Length && !b)
{
b:=(v[i]<0);
i:=i+1;
}
if (b){i:=i-1;}
}
method mfirstNegative2(v:array<int>) returns (b:bool, i:int)
ensures b <==> exists k::0<=k<v.Length && v[k]<0
ensures b ==> 0<=i<v.Length && v[i]<0 && positive(v[0..i])
{
i:=0;b:=false;
while (i<v.Length && !b)
{
b:=(v[i]<0);
if (!b) {i:=i+1;}
}
}
| predicate positive(s:seq<int>)
{forall u::0<=u<|s| ==> s[u]>=0}
method mfirstNegative(v:array<int>) returns (b:bool, i:int)
ensures b <==> exists k::0<=k<v.Length && v[k]<0
ensures b ==> 0<=i<v.Length && v[i]<0 && positive(v[0..i])
{
i:=0;
b:=false;
while (i<v.Length && !b)
invariant 0<=i<=v.Length
invariant b <==> exists k::0<=k<i && v[k]<0
invariant b ==> v[i-1]<0 && positive(v[0..i-1])
decreases v.Length - i
{
b:=(v[i]<0);
i:=i+1;
}
if (b){i:=i-1;}
}
method mfirstNegative2(v:array<int>) returns (b:bool, i:int)
ensures b <==> exists k::0<=k<v.Length && v[k]<0
ensures b ==> 0<=i<v.Length && v[i]<0 && positive(v[0..i])
{
i:=0;b:=false;
while (i<v.Length && !b)
invariant 0<=i<=v.Length
invariant b ==> i<v.Length && v[i]<0 && !(exists k::0<=k<i && v[k]<0)
invariant b <== exists k::0<=k<i && v[k]<0
decreases v.Length - i - (if b then 1 else 0)
{
b:=(v[i]<0);
if (!b) {i:=i+1;}
}
}
| Dafny-Exercises_tmp_tmpjm75muf__Session4Exercises_ExerciseFirstNegative.dfy | 55 |
method mfirstCero(v:array<int>) returns (i:int)
ensures 0 <=i<=v.Length
ensures forall j:: 0<=j<i ==> v[j]!=0
ensures i!=v.Length ==> v[i]==0
{
i:=0;
while (i<v.Length && v[i]!=0)
{i:=i+1;}
}
|
method mfirstCero(v:array<int>) returns (i:int)
ensures 0 <=i<=v.Length
ensures forall j:: 0<=j<i ==> v[j]!=0
ensures i!=v.Length ==> v[i]==0
{
i:=0;
while (i<v.Length && v[i]!=0)
invariant 0<=i<=v.Length
invariant forall j:: 0<=j<i ==> v[j]!=0
decreases v.Length -i
{i:=i+1;}
}
| Dafny-Exercises_tmp_tmpjm75muf__Session4Exercises_ExercisefirstZero.dfy | 56 |
function SumR(s:seq<int>):int
{
if (s==[]) then 0
else SumR(s[..|s|-1])+s[|s|-1]
}
function SumL(s:seq<int>):int
{
if (s==[]) then 0
else s[0]+SumL(s[1..])
}
lemma concatLast(s:seq<int>,t:seq<int>)
requires t!=[]
ensures (s+t)[..|s+t|-1] == s+(t[..|t|-1])
{}
lemma concatFirst(s:seq<int>,t:seq<int>)
requires s!=[]
ensures (s+t)[1..] == s[1..]+t
{}
lemma {:induction s,t} SumByPartsR(s:seq<int>,t:seq<int>)
ensures SumR(s+t) == SumR(s)+SumR(t)
{ if (t==[])
{assert s+t == s;}
else if (s==[])
{assert s+t==t;}
else
{
calc =={
SumR(s+t);
SumR((s+t)[..|s+t|-1])+(s+t)[|s+t|-1];
SumR((s+t)[..|s+t|-1])+t[|t|-1];
{concatLast(s,t);}
SumR(s+t[..|t|-1])+t[|t|-1];
{SumByPartsR(s,t[..|t|-1]);}
SumR(s)+SumR(t[..|t|-1])+t[|t|-1];
SumR(s)+SumR(t);
}
}
}
lemma {:induction s,t} SumByPartsL(s:seq<int>,t:seq<int>)
ensures SumL(s+t) == SumL(s)+SumL(t)
//Prove this
{
if(t==[]){
}
else if(s==[]){
}
else{
calc == {
SumL(s+t);
(s+t)[0] + SumL((s+t)[1..]);
s[0] + SumL((s+t)[1..]);
{concatFirst(s,t);}
s[0] + SumL(s[1..] + t);
{SumByPartsL(s[1..], t);}
s[0] + SumL(s[1..]) + SumL(t);
}
}
}
lemma {:induction s,i,j} equalSumR(s:seq<int>,i:int,j:int)
requires 0<=i<=j<=|s|
ensures SumR(s[i..j])==SumL(s[i..j])
//Prove this
{
if(s==[]){
}else{
if(i==j){
}
else{
calc == {
SumR(s[i..j]);
{
}
SumR(s[i..j-1]) + s[j-1];
{equalSumR(s, i, j-1);}
SumL(s[i..j-1]) + s[j-1];
{assert s[j-1] == SumL([s[j-1]]);}
SumL(s[i..j-1]) + SumL([s[j-1]]);
{SumByPartsL(s[i..j-1], [s[j-1]]);}
SumL(s[i..j-1] + [s[j-1]]);
{
}
SumL(s[i..j]);
/*SumR(s[i..j-1])+SumR(s[j..j]);
SumR(s[i..j-1]) + s[j..j];
SumL(s);*/
}
}
}
}
lemma equalSumsV()
ensures forall v:array<int>,i,j | 0<=i<=j<=v.Length :: SumR(v[i..j])==SumL(v[i..j])
//proving the forall
{ forall v:array<int>,i,j | 0<=i<=j<=v.Length
ensures SumR(v[i..j])==SumL(v[i..j])
{equalSumR(v[..],i,j);}
}
function SumV(v:array<int>,c:int,f:int):int
requires 0<=c<=f<=v.Length
reads v
{SumR(v[c..f])}
lemma ArrayFacts<T>()
ensures forall v : array<T> :: v[..v.Length] == v[..];
ensures forall v : array<T> :: v[0..] == v[..];
ensures forall v : array<T> :: v[0..v.Length] == v[..];
ensures forall v : array<T> ::|v[0..v.Length]|==v.Length;
ensures forall v : array<T> | v.Length>=1 ::|v[1..v.Length]|==v.Length-1;
ensures forall v : array<T> ::forall k : nat | k < v.Length :: v[..k+1][..k] == v[..k]
// ensures forall v:array<int>,i,j | 0<=i<=j<=v.Length :: SumR(v[i..j])==SumL(v[i..j])
{equalSumsV();}
method sumElems(v:array<int>) returns (sum:int)
//ensures sum==SumL(v[0..v.Length])
ensures sum==SumR(v[..])
//ensures sum==SumV(v,0,v.Length)
{ArrayFacts<int>();
sum:=0;
var i:int;
i:=0;
while (i<v.Length)
{
sum:=sum+v[i];
i:=i+1;
}
}
method sumElemsB(v:array<int>) returns (sum:int)
//ensures sum==SumL(v[0..v.Length])
ensures sum==SumR(v[0..v.Length])
{
ArrayFacts<int>();
sum:=0;
var i:int;
i:=v.Length;
equalSumsV();
while(i>0)
{
sum:=sum+v[i-1];
i:=i-1;
}
}
| function SumR(s:seq<int>):int
decreases s
{
if (s==[]) then 0
else SumR(s[..|s|-1])+s[|s|-1]
}
function SumL(s:seq<int>):int
decreases s
{
if (s==[]) then 0
else s[0]+SumL(s[1..])
}
lemma concatLast(s:seq<int>,t:seq<int>)
requires t!=[]
ensures (s+t)[..|s+t|-1] == s+(t[..|t|-1])
{}
lemma concatFirst(s:seq<int>,t:seq<int>)
requires s!=[]
ensures (s+t)[1..] == s[1..]+t
{}
lemma {:induction s,t} SumByPartsR(s:seq<int>,t:seq<int>)
decreases s,t
ensures SumR(s+t) == SumR(s)+SumR(t)
{ if (t==[])
{assert s+t == s;}
else if (s==[])
{assert s+t==t;}
else
{
calc =={
SumR(s+t);
SumR((s+t)[..|s+t|-1])+(s+t)[|s+t|-1];
SumR((s+t)[..|s+t|-1])+t[|t|-1];
{concatLast(s,t);}
SumR(s+t[..|t|-1])+t[|t|-1];
{SumByPartsR(s,t[..|t|-1]);}
SumR(s)+SumR(t[..|t|-1])+t[|t|-1];
SumR(s)+SumR(t);
}
}
}
lemma {:induction s,t} SumByPartsL(s:seq<int>,t:seq<int>)
decreases s,t
ensures SumL(s+t) == SumL(s)+SumL(t)
//Prove this
{
if(t==[]){
assert s+t==s;
}
else if(s==[]){
assert s+t==t;
}
else{
calc == {
SumL(s+t);
(s+t)[0] + SumL((s+t)[1..]);
s[0] + SumL((s+t)[1..]);
{concatFirst(s,t);}
s[0] + SumL(s[1..] + t);
{SumByPartsL(s[1..], t);}
s[0] + SumL(s[1..]) + SumL(t);
}
}
}
lemma {:induction s,i,j} equalSumR(s:seq<int>,i:int,j:int)
decreases j-i
requires 0<=i<=j<=|s|
ensures SumR(s[i..j])==SumL(s[i..j])
//Prove this
{
if(s==[]){
assert SumR(s) == SumL(s);
}else{
if(i==j){
assert SumR(s[i..j]) == SumL(s[i..j]);
}
else{
calc == {
SumR(s[i..j]);
{
assert s[i..j] == s[i..j-1] + [s[j-1]];
assert SumR(s[i..j]) == SumR(s[i..j-1]) + s[j-1];
}
SumR(s[i..j-1]) + s[j-1];
{equalSumR(s, i, j-1);}
SumL(s[i..j-1]) + s[j-1];
{assert s[j-1] == SumL([s[j-1]]);}
SumL(s[i..j-1]) + SumL([s[j-1]]);
{SumByPartsL(s[i..j-1], [s[j-1]]);}
SumL(s[i..j-1] + [s[j-1]]);
{
assert s[i..j] == s[i..j-1] + [s[j-1]];
}
SumL(s[i..j]);
/*SumR(s[i..j-1])+SumR(s[j..j]);
SumR(s[i..j-1]) + s[j..j];
SumL(s);*/
}
}
}
}
lemma equalSumsV()
ensures forall v:array<int>,i,j | 0<=i<=j<=v.Length :: SumR(v[i..j])==SumL(v[i..j])
//proving the forall
{ forall v:array<int>,i,j | 0<=i<=j<=v.Length
ensures SumR(v[i..j])==SumL(v[i..j])
{equalSumR(v[..],i,j);}
}
function SumV(v:array<int>,c:int,f:int):int
requires 0<=c<=f<=v.Length
reads v
{SumR(v[c..f])}
lemma ArrayFacts<T>()
ensures forall v : array<T> :: v[..v.Length] == v[..];
ensures forall v : array<T> :: v[0..] == v[..];
ensures forall v : array<T> :: v[0..v.Length] == v[..];
ensures forall v : array<T> ::|v[0..v.Length]|==v.Length;
ensures forall v : array<T> | v.Length>=1 ::|v[1..v.Length]|==v.Length-1;
ensures forall v : array<T> ::forall k : nat | k < v.Length :: v[..k+1][..k] == v[..k]
// ensures forall v:array<int>,i,j | 0<=i<=j<=v.Length :: SumR(v[i..j])==SumL(v[i..j])
{equalSumsV();}
method sumElems(v:array<int>) returns (sum:int)
//ensures sum==SumL(v[0..v.Length])
ensures sum==SumR(v[..])
//ensures sum==SumV(v,0,v.Length)
{ArrayFacts<int>();
sum:=0;
var i:int;
i:=0;
while (i<v.Length)
decreases v.Length - i//write
invariant 0<=i<=v.Length && sum == SumR(v[..i])//write
{
sum:=sum+v[i];
i:=i+1;
}
}
method sumElemsB(v:array<int>) returns (sum:int)
//ensures sum==SumL(v[0..v.Length])
ensures sum==SumR(v[0..v.Length])
{
ArrayFacts<int>();
sum:=0;
var i:int;
i:=v.Length;
equalSumsV();
while(i>0)
decreases i//write
invariant 0<=i<=v.Length
invariant sum == SumL(v[i..]) == SumR(v[i..])
{
sum:=sum+v[i-1];
i:=i-1;
}
}
| Dafny-Exercises_tmp_tmpjm75muf__Session5Exercises_ExerciseSumElems.dfy | 57 |
predicate positive(s:seq<int>)
{forall u::0<=u<|s| ==> s[u]>=0}
predicate isEven(i:int)
requires i>=0
{i%2==0}
function CountEven(s:seq<int>):int
requires positive(s)
{if s==[] then 0
else (if (s[|s|-1]%2==0) then 1 else 0)+CountEven(s[..|s|-1])
}
lemma ArrayFacts<T>()
ensures forall v : array<T> :: v[..v.Length] == v[..];
ensures forall v : array<T> :: v[0..] == v[..];
ensures forall v : array<T> :: v[0..v.Length] == v[..];
ensures forall v : array<T> ::|v[0..v.Length]|==v.Length;
ensures forall v : array<T> | v.Length>=1 ::|v[1..v.Length]|==v.Length-1;
ensures forall v : array<T> ::forall k : nat | k < v.Length :: v[..k+1][..k] == v[..k]
{}
method mcountEven(v:array<int>) returns (n:int)
requires positive(v[..])
ensures n==CountEven(v[..])
{ ArrayFacts<int>();
n:=0;
var i:int;
i:=0;
while (i<v.Length)
{
if (v[i]%2==0) {n:=n+1;}
i:=i+1;
}
}
|
predicate positive(s:seq<int>)
{forall u::0<=u<|s| ==> s[u]>=0}
predicate isEven(i:int)
requires i>=0
{i%2==0}
function CountEven(s:seq<int>):int
decreases s
requires positive(s)
{if s==[] then 0
else (if (s[|s|-1]%2==0) then 1 else 0)+CountEven(s[..|s|-1])
}
lemma ArrayFacts<T>()
ensures forall v : array<T> :: v[..v.Length] == v[..];
ensures forall v : array<T> :: v[0..] == v[..];
ensures forall v : array<T> :: v[0..v.Length] == v[..];
ensures forall v : array<T> ::|v[0..v.Length]|==v.Length;
ensures forall v : array<T> | v.Length>=1 ::|v[1..v.Length]|==v.Length-1;
ensures forall v : array<T> ::forall k : nat | k < v.Length :: v[..k+1][..k] == v[..k]
{}
method mcountEven(v:array<int>) returns (n:int)
requires positive(v[..])
ensures n==CountEven(v[..])
{ ArrayFacts<int>();
n:=0;
var i:int;
i:=0;
while (i<v.Length)
decreases v.Length - i//write
invariant 0<=i<=v.Length//write
invariant n==CountEven(v[..i])
{
if (v[i]%2==0) {n:=n+1;}
i:=i+1;
}
}
| Dafny-Exercises_tmp_tmpjm75muf__Session6Exercises_ExerciseCountEven.dfy | 58 |
function min(v:array<int>,i:int):int
reads v
requires 1<=i<=v.Length
ensures forall k::0<=k<i==> v[k]>=min(v,i)
{if (i==1) then v[0]
else if (v[i-1]<=min(v,i-1)) then v[i-1]
else min(v,i-1)
}
function countMin(v:array<int>,x:int, i:int):int
reads v
requires 0<=i<=v.Length
ensures !(x in v[0..i]) ==> countMin(v,x,i)==0
{
if (i==0) then 0
else if (v[i-1]==x) then 1+countMin(v,x,i-1)
else countMin(v,x,i-1)
}
method mCountMin(v:array<int>) returns (c:int)
requires v.Length>0
ensures c==countMin(v,min(v,v.Length),v.Length)
//Implement and verify an O(v.Length) algorithm
{
var i:=1;
c:=1;
var mini:=v[0];
while(i<v.Length)
{
if(v[i]==mini){
c:=c + 1;
}
else if(v[i]<mini){
c:=1;
mini:=v[i];
}
i:=i+1;
}
}
| function min(v:array<int>,i:int):int
decreases i
reads v
requires 1<=i<=v.Length
ensures forall k::0<=k<i==> v[k]>=min(v,i)
{if (i==1) then v[0]
else if (v[i-1]<=min(v,i-1)) then v[i-1]
else min(v,i-1)
}
function countMin(v:array<int>,x:int, i:int):int
decreases i
reads v
requires 0<=i<=v.Length
ensures !(x in v[0..i]) ==> countMin(v,x,i)==0
{
if (i==0) then 0
else if (v[i-1]==x) then 1+countMin(v,x,i-1)
else countMin(v,x,i-1)
}
method mCountMin(v:array<int>) returns (c:int)
requires v.Length>0
ensures c==countMin(v,min(v,v.Length),v.Length)
//Implement and verify an O(v.Length) algorithm
{
var i:=1;
c:=1;
var mini:=v[0];
while(i<v.Length)
decreases v.Length -i
invariant 0<i<=v.Length
invariant mini==min(v,i)
invariant c==countMin(v, mini, i)
{
if(v[i]==mini){
c:=c + 1;
}
else if(v[i]<mini){
c:=1;
mini:=v[i];
}
i:=i+1;
}
}
| Dafny-Exercises_tmp_tmpjm75muf__Session6Exercises_ExerciseCountMin.dfy | 59 |
predicate isPeek(v:array<int>,i:int)
reads v
requires 0<=i<v.Length
{forall k::0<=k<i ==> v[i]>=v[k]}
function peekSum(v:array<int>,i:int):int
reads v
requires 0<=i<=v.Length
{
if (i==0) then 0
else if isPeek(v,i-1) then v[i-1]+peekSum(v,i-1)
else peekSum(v,i-1)
}
method mPeekSum(v:array<int>) returns (sum:int)
requires v.Length>0
ensures sum==peekSum(v,v.Length)
//Implement and verify an O(v.Length) algorithm to solve this problem
{
var i:=1;
sum:=v[0];
var lmax:=v[0];
while(i<v.Length)
{
if(v[i]>=lmax){
sum:=sum + v[i];
lmax:=v[i];
}
i:=i+1;
}
}
|
predicate isPeek(v:array<int>,i:int)
reads v
requires 0<=i<v.Length
{forall k::0<=k<i ==> v[i]>=v[k]}
function peekSum(v:array<int>,i:int):int
decreases i
reads v
requires 0<=i<=v.Length
{
if (i==0) then 0
else if isPeek(v,i-1) then v[i-1]+peekSum(v,i-1)
else peekSum(v,i-1)
}
method mPeekSum(v:array<int>) returns (sum:int)
requires v.Length>0
ensures sum==peekSum(v,v.Length)
//Implement and verify an O(v.Length) algorithm to solve this problem
{
var i:=1;
sum:=v[0];
var lmax:=v[0];
while(i<v.Length)
decreases v.Length -i
invariant 0<i<=v.Length
invariant lmax in v[..i]
invariant forall k::0<=k<i ==> lmax>=v[k];
invariant sum==peekSum(v, i)
{
if(v[i]>=lmax){
sum:=sum + v[i];
lmax:=v[i];
}
i:=i+1;
}
}
| Dafny-Exercises_tmp_tmpjm75muf__Session6Exercises_ExercisePeekSum.dfy | 60 |
predicate sorted(s : seq<int>) {
forall u, w :: 0 <= u < w < |s| ==> s[u] <= s[w]
}
method binarySearch(v:array<int>, elem:int) returns (p:int)
requires sorted(v[0..v.Length])
ensures -1<=p<v.Length
ensures (forall u::0<=u<=p ==> v[u]<=elem) && (forall w::p<w<v.Length ==> v[w]>elem)
{
var c,f:=0,v.Length-1;
while (c<=f)
(forall w::f<w<v.Length ==> v[w]>elem)
{
var m:=(c+f)/2;
if (v[m]<=elem)
{c:=m+1;}
else {f:=m-1;}
}
p:=c-1;
}
method search(v:array<int>,elem:int) returns (b:bool)
requires sorted(v[0..v.Length])
ensures b==(elem in v[0..v.Length])
//Implement by calling binary search function
{
var p:=binarySearch(v, elem);
if(p==-1){
b:= false;
}
else{
b:=v[p] == elem;
}
}
//Recursive binary search
method {:tailrecursion false} binarySearchRec(v:array<int>, elem:int, c:int, f:int) returns (p:int)
requires sorted(v[0..v.Length])
requires 0<=c<=f+1<=v.Length//0<=c<=v.Length && -1<=f<v.Length && c<=f+1
requires forall k::0<=k<c ==> v[k]<=elem
requires forall k::f<k<v.Length ==> v[k]>elem
ensures -1<=p<v.Length
ensures (forall u::0<=u<=p ==> v[u]<=elem) && (forall w::p<w<v.Length ==> v[w]>elem)
{
if (c==f+1)
{p:=c-1;} //empty case: c-1 contains the last element less or equal than elem
else
{
var m:=(c+f)/2;
if (v[m]<=elem)
{p:=binarySearchRec(v,elem,m+1,f);}
else
{p:=binarySearchRec(v,elem,c,m-1);}
}
}
method otherbSearch(v:array<int>, elem:int) returns (b:bool,p:int)
requires sorted(v[0..v.Length])
ensures 0<=p<=v.Length
ensures b == (elem in v[0..v.Length])
ensures b ==> p<v.Length && v[p]==elem
ensures !b ==> (forall u::0<=u<p ==> v[u]<elem) &&
(forall w::p<=w<v.Length ==> v[w]>elem)
//Implement and verify
{
p:=binarySearch(v, elem);
if(p==-1){
b:= false;
p:=p+1;
}
else{
b:=v[p] == elem;
p:=p + if b then 0 else 1;
}
}
| predicate sorted(s : seq<int>) {
forall u, w :: 0 <= u < w < |s| ==> s[u] <= s[w]
}
method binarySearch(v:array<int>, elem:int) returns (p:int)
requires sorted(v[0..v.Length])
ensures -1<=p<v.Length
ensures (forall u::0<=u<=p ==> v[u]<=elem) && (forall w::p<w<v.Length ==> v[w]>elem)
{
var c,f:=0,v.Length-1;
while (c<=f)
decreases f-c
invariant 0<=c<=v.Length && -1<=f<=v.Length-1 && c<=f+1
invariant (forall u::0<=u<c ==> v[u]<=elem) &&
(forall w::f<w<v.Length ==> v[w]>elem)
{
var m:=(c+f)/2;
if (v[m]<=elem)
{c:=m+1;}
else {f:=m-1;}
}
p:=c-1;
}
method search(v:array<int>,elem:int) returns (b:bool)
requires sorted(v[0..v.Length])
ensures b==(elem in v[0..v.Length])
//Implement by calling binary search function
{
var p:=binarySearch(v, elem);
if(p==-1){
b:= false;
}
else{
b:=v[p] == elem;
}
}
//Recursive binary search
method {:tailrecursion false} binarySearchRec(v:array<int>, elem:int, c:int, f:int) returns (p:int)
requires sorted(v[0..v.Length])
requires 0<=c<=f+1<=v.Length//0<=c<=v.Length && -1<=f<v.Length && c<=f+1
requires forall k::0<=k<c ==> v[k]<=elem
requires forall k::f<k<v.Length ==> v[k]>elem
decreases f-c
ensures -1<=p<v.Length
ensures (forall u::0<=u<=p ==> v[u]<=elem) && (forall w::p<w<v.Length ==> v[w]>elem)
{
if (c==f+1)
{p:=c-1;} //empty case: c-1 contains the last element less or equal than elem
else
{
var m:=(c+f)/2;
if (v[m]<=elem)
{p:=binarySearchRec(v,elem,m+1,f);}
else
{p:=binarySearchRec(v,elem,c,m-1);}
}
}
method otherbSearch(v:array<int>, elem:int) returns (b:bool,p:int)
requires sorted(v[0..v.Length])
ensures 0<=p<=v.Length
ensures b == (elem in v[0..v.Length])
ensures b ==> p<v.Length && v[p]==elem
ensures !b ==> (forall u::0<=u<p ==> v[u]<elem) &&
(forall w::p<=w<v.Length ==> v[w]>elem)
//Implement and verify
{
p:=binarySearch(v, elem);
if(p==-1){
b:= false;
p:=p+1;
}
else{
b:=v[p] == elem;
p:=p + if b then 0 else 1;
}
}
| Dafny-Exercises_tmp_tmpjm75muf__Session7Exercises_ExerciseBinarySearch.dfy | 61 |
predicate sorted_seg(a:array<int>, i:int, j:int) //j excluded
requires 0 <= i <= j <= a.Length
reads a
{
forall l, k :: i <= l <= k < j ==> a[l] <= a[k]
}
method bubbleSorta(a:array<int>, c:int, f:int)//f excluded
modifies a
requires 0 <= c <= f <= a.Length //when c==f empty sequence
ensures sorted_seg(a,c,f)
ensures multiset(a[c..f]) == old(multiset(a[c..f]))
ensures a[..c]==old(a[..c]) && a[f..]==old(a[f..])
{
var i:=c;
while (i< f)
{
var j:=f-1;
while (j > i)
{
//assert a[j]
//assert multiset(a[c..f]) == old(multiset(a[c..f])) ;
if (a[j-1]>a[j]){
a[j],a[j-1]:=a[j-1],a[j];
}
j:=j-1;
}
i:=i+1;
}
}
method bubbleSort(a:array<int>, c:int, f:int)//f excluded
modifies a
requires 0 <= c <= f <= a.Length //when c==f empty sequence
ensures sorted_seg(a,c,f)
ensures multiset(a[c..f]) == old(multiset(a[c..f]))
ensures a[..c]==old(a[..c]) && a[f..]==old(a[f..])
{
var i:=c;
var b:=true;
while (i<f && b)
{
var j:=f-1;
b:=false;
while (j>i)
{
if (a[j-1]>a[j]) {
a[j],a[j-1]:=a[j-1],a[j];
b:=true;
}
j:=j-1;
}
i:=i+1;
}
}
| predicate sorted_seg(a:array<int>, i:int, j:int) //j excluded
requires 0 <= i <= j <= a.Length
reads a
{
forall l, k :: i <= l <= k < j ==> a[l] <= a[k]
}
method bubbleSorta(a:array<int>, c:int, f:int)//f excluded
modifies a
requires 0 <= c <= f <= a.Length //when c==f empty sequence
ensures sorted_seg(a,c,f)
ensures multiset(a[c..f]) == old(multiset(a[c..f]))
ensures a[..c]==old(a[..c]) && a[f..]==old(a[f..])
{
var i:=c;
while (i< f)
decreases a.Length-i
invariant c<=i<=f
invariant sorted_seg(a,c,i)
invariant forall k,l::c<=k< i && i<=l< f ==> a[k]<=a[l]
invariant multiset(a[c..f]) == old(multiset(a[c..f]))
invariant a[..c]==old(a[..c]) && a[f..]==old(a[f..])
{
var j:=f-1;
assert multiset(a[c..f]) == old(multiset(a[c..f])) ;
while (j > i)
decreases j-i//write
invariant i <= j<= f-1//write
invariant forall k::j<=k<=f-1 ==> a[j] <= a[k]
invariant forall k,l::c<=k< i && i<=l< f ==> a[k]<=a[l]
invariant sorted_seg(a,c,i)
invariant multiset(a[c..f]) == old(multiset(a[c..f]))
invariant a[..c]==old(a[..c]) && a[f..]==old(a[f..])
{
//assert a[j]
//assert multiset(a[c..f]) == old(multiset(a[c..f])) ;
if (a[j-1]>a[j]){
a[j],a[j-1]:=a[j-1],a[j];
}
j:=j-1;
}
assert sorted_seg(a,c,i+1);
assert forall k::i<k<f ==> a[i]<=a[k];
i:=i+1;
}
}
method bubbleSort(a:array<int>, c:int, f:int)//f excluded
modifies a
requires 0 <= c <= f <= a.Length //when c==f empty sequence
ensures sorted_seg(a,c,f)
ensures multiset(a[c..f]) == old(multiset(a[c..f]))
ensures a[..c]==old(a[..c]) && a[f..]==old(a[f..])
{
var i:=c;
var b:=true;
while (i<f && b)
decreases a.Length-i
invariant c<=i<=f
invariant sorted_seg(a,c,i)
invariant forall k,l::c<=k<i && i<=l<f ==> a[k]<=a[l]
invariant multiset(a[c..f]) == old(multiset(a[c..f]))
invariant a[..c]==old(a[..c]) && a[f..]==old(a[f..])
invariant !b ==> sorted_seg(a,i,f)
{
var j:=f-1;
b:=false;
assert multiset(a[c..f]) == old(multiset(a[c..f])) ;
while (j>i)
decreases j-i//write
invariant i<=j<=f-1//write
invariant forall k::j<=k<=f-1 ==> a[j] <= a[k]
invariant forall k,l::c<=k<i && i<=l<f ==> a[k]<=a[l]
invariant sorted_seg(a,c,i)
invariant a[..c]==old(a[..c]) && a[f..]==old(a[f..])
invariant !b ==> sorted_seg(a,j,f)
invariant multiset(a[c..f]) == old(multiset(a[c..f]))
{
if (a[j-1]>a[j]) {
a[j],a[j-1]:=a[j-1],a[j];
b:=true;
}
j:=j-1;
}
assert !b ==> sorted_seg(a,i,f);
i:=i+1;
}
}
| Dafny-Exercises_tmp_tmpjm75muf__Session7Exercises_ExerciseBubbleSort.dfy | 62 |
method replace(v:array<int>, x:int, y:int)
modifies v
ensures forall k::0<=k<old(v.Length) && old(v[k])==x ==> v[k]==y
ensures forall k::0<=k<old(v.Length) && old(v[k])!=x ==> v[k]==old(v[k])
{
var i:=0;
while(i<v.Length)
{
if(v[i]==x){
v[i]:=y;
}
i:=i+1;
}
}
|
method replace(v:array<int>, x:int, y:int)
modifies v
ensures forall k::0<=k<old(v.Length) && old(v[k])==x ==> v[k]==y
ensures forall k::0<=k<old(v.Length) && old(v[k])!=x ==> v[k]==old(v[k])
{
var i:=0;
while(i<v.Length)
decreases v.Length - i
invariant 0<=i<=v.Length
invariant forall k::0<=k<i && old(v[k])==x ==> v[k]==y
invariant forall k::i<=k<v.Length ==> v[k] == old(v[k])
invariant forall k::0<=k<i && old(v[k])!=x ==> v[k]==old(v[k])
{
if(v[i]==x){
v[i]:=y;
}
i:=i+1;
}
}
| Dafny-Exercises_tmp_tmpjm75muf__Session7Exercises_ExerciseReplace.dfy | 63 |
predicate sorted_seg(a:array<int>, i:int, j:int) //j not included
requires 0 <= i <= j <= a.Length
reads a
{
forall l, k :: i <= l <= k < j ==> a[l] <= a[k]
}
method selSort (a:array<int>, c:int, f:int)//f excluded
modifies a
requires 0 <= c <= f <= a.Length //when c==f empty sequence
ensures sorted_seg(a,c,f)
ensures multiset(a[c..f]) == old(multiset(a[c..f]))
ensures a[..c]==old(a[..c]) && a[f..]==old(a[f..])
{if (c<=f-1){//two elements at least
var i:=c;
while (i<f-1) //outer loop
{
var less:=i;
var j:=i+1;
while (j<f) //inner loop
{ if (a[j]<a[less]) {less:=j;}
j:=j+1;
}
a[i],a[less]:=a[less],a[i];
i:=i+1;
}
}
}
| predicate sorted_seg(a:array<int>, i:int, j:int) //j not included
requires 0 <= i <= j <= a.Length
reads a
{
forall l, k :: i <= l <= k < j ==> a[l] <= a[k]
}
method selSort (a:array<int>, c:int, f:int)//f excluded
modifies a
requires 0 <= c <= f <= a.Length //when c==f empty sequence
ensures sorted_seg(a,c,f)
ensures multiset(a[c..f]) == old(multiset(a[c..f]))
ensures a[..c]==old(a[..c]) && a[f..]==old(a[f..])
{if (c<=f-1){//two elements at least
var i:=c;
while (i<f-1) //outer loop
decreases f-i
invariant c<=i<=f
invariant sorted_seg(a,c,i)
invariant forall k,l::c<=k<i && i<=l<f ==> a[k]<=a[l]
invariant multiset(a[c..f]) == old(multiset(a[c..f]))
invariant a[..c]==old(a[..c]) && a[f..]==old(a[f..])
{
var less:=i;
var j:=i+1;
while (j<f) //inner loop
decreases f-j//write
invariant i+1<=j<=f//write
invariant i<=less<f
invariant sorted_seg(a,c,i)
invariant forall k::i<=k<j ==> a[less] <= a[k]
invariant forall k,l::c<=k<i && i<=l<f ==> a[k]<=a[l]
invariant multiset(a[c..f]) == old(multiset(a[c..f]))
invariant a[..c]==old(a[..c]) && a[f..]==old(a[f..])
{ if (a[j]<a[less]) {less:=j;}
j:=j+1;
}
a[i],a[less]:=a[less],a[i];
i:=i+1;
}
}
}
| Dafny-Exercises_tmp_tmpjm75muf__Session7Exercises_ExerciseSelSort.dfy | 64 |
predicate strictNegative(v:array<int>,i:int,j:int)
reads v
requires 0<=i<=j<=v.Length
{forall u | i<=u<j :: v[u]<0}
predicate positive(s:seq<int>)
{forall u::0<=u<|s| ==> s[u]>=0}
predicate isPermutation(s:seq<int>, t:seq<int>)
{multiset(s)==multiset(t)}
/**
returns an index st new array is a permutation of the old array
positive first and then strictnegative, i is the firs neg or len if not any */
method separate(v:array<int>) returns (i:int)
modifies v
ensures 0<=i<=v.Length
ensures positive(v[0..i]) && strictNegative(v,i,v.Length)
ensures isPermutation(v[0..v.Length], old(v[0..v.Length]))
{
i:=0;
var j:=v.Length - 1;
while(i<=j)
{
if(v[i]>=0){
i:=i+1;
}
else if(v[j]>=0){
v[i],v[j]:=v[j],v[i];
j:=j-1;
i:=i+1;
}
else if(v[j]<0){
j:=j-1;
}
}
}
| predicate strictNegative(v:array<int>,i:int,j:int)
reads v
requires 0<=i<=j<=v.Length
{forall u | i<=u<j :: v[u]<0}
predicate positive(s:seq<int>)
{forall u::0<=u<|s| ==> s[u]>=0}
predicate isPermutation(s:seq<int>, t:seq<int>)
{multiset(s)==multiset(t)}
/**
returns an index st new array is a permutation of the old array
positive first and then strictnegative, i is the firs neg or len if not any */
method separate(v:array<int>) returns (i:int)
modifies v
ensures 0<=i<=v.Length
ensures positive(v[0..i]) && strictNegative(v,i,v.Length)
ensures isPermutation(v[0..v.Length], old(v[0..v.Length]))
{
i:=0;
var j:=v.Length - 1;
while(i<=j)
decreases j-i
invariant 0<=i<=j+1<=v.Length
invariant strictNegative(v,j+1,v.Length)
invariant positive(v[0..i])
invariant isPermutation(v[0..v.Length], old(v[0..v.Length]))
{
if(v[i]>=0){
i:=i+1;
}
else if(v[j]>=0){
assert v[i]<0;
v[i],v[j]:=v[j],v[i];
j:=j-1;
i:=i+1;
}
else if(v[j]<0){
j:=j-1;
}
}
}
| Dafny-Exercises_tmp_tmpjm75muf__Session7Exercises_ExerciseSeparate.dfy | 65 |
predicate sorted_seg(a:array<int>, i:int, j:int) //i and j included
requires 0 <= i <= j+1 <= a.Length
reads a
{
forall l, k :: i <= l <= k <= j ==> a[l] <= a[k]
}
method InsertionSort(a: array<int>)
modifies a;
ensures sorted_seg(a,0,a.Length-1)
ensures multiset(a[..]) == old(multiset(a[..])) //Add and prove this
{
var i := 0;
while (i < a.Length)
{
var temp := a[i];
var j := i;
while (j > 0 && temp < a[j - 1])
{
a[j] := a[j - 1];
j := j - 1;
}
a[j] := temp;
i := i + 1;
}
}
|
predicate sorted_seg(a:array<int>, i:int, j:int) //i and j included
requires 0 <= i <= j+1 <= a.Length
reads a
{
forall l, k :: i <= l <= k <= j ==> a[l] <= a[k]
}
method InsertionSort(a: array<int>)
modifies a;
ensures sorted_seg(a,0,a.Length-1)
ensures multiset(a[..]) == old(multiset(a[..])) //Add and prove this
{
var i := 0;
assert multiset(a[..]) == old(multiset(a[..]));
while (i < a.Length)
decreases a.Length-i
invariant 0<=i<=a.Length
invariant sorted_seg(a,0,i-1)
invariant multiset(a[..]) == old(multiset(a[..]))//add
invariant forall k::i<k<a.Length ==> a[k] == old(a[k])
{
var temp := a[i];
var j := i;
while (j > 0 && temp < a[j - 1])
decreases j
invariant 0<=j<=i
invariant sorted_seg(a,0,j-1) && sorted_seg(a,j+1,i)
invariant forall k,l :: 0<=k<=j-1 && j+1<=l<=i ==> a[k]<=a[l]
invariant forall k :: j<k<=i ==> temp <a[k]
invariant forall k::i<k<a.Length ==> a[k] == old(a[k])
invariant multiset(a[..]) - multiset{a[j]} + multiset{temp} == old(multiset(a[..]))//add
{
a[j] := a[j - 1];
j := j - 1;
}
a[j] := temp;
i := i + 1;
}
}
| Dafny-Exercises_tmp_tmpjm75muf__Session8Exercises_ExerciseInsertionSort.dfy | 66 |
function Sum(v:array<int>,i:int,j:int):int
reads v
requires 0<=i<=j<=v.Length
{
if (i==j) then 0
else Sum(v,i,j-1)+v[j-1]
}
predicate SumMaxToRight(v:array<int>,i:int,s:int)
reads v
requires 0<=i<v.Length
{
forall l,ss {:induction l}::0<=l<=i && ss==i+1==> Sum(v,l,ss)<=s
}
method segMaxSum(v:array<int>,i:int) returns (s:int,k:int)
requires v.Length>0 && 0<=i<v.Length
ensures 0<=k<=i && s==Sum(v,k,i+1) && SumMaxToRight(v,i,s)
{
s:=v[0];
k:=0;
var j:=0;
while (j<i)
{
if (s+v[j+1]>v[j+1]) {s:=s+v[j+1];}
else {k:=j+1;s:=v[j+1];}
j:=j+1;
}
}
function Sum2(v:array<int>,i:int,j:int):int
reads v
requires 0<=i<=j<=v.Length
{
if (i==j) then 0
else v[i]+Sum2(v,i+1,j)
}
//Now do the same but with a loop from right to left
predicate SumMaxToRight2(v:array<int>,j:int,i:int,s:int)//maximum sum stuck to the right
reads v
requires 0<=j<=i<v.Length
{(forall l,ss {:induction l}::j<=l<=i && ss==i+1 ==> Sum2(v,l,ss)<=s)}
method segSumaMaxima2(v:array<int>,i:int) returns (s:int,k:int)
requires v.Length>0 && 0<=i<v.Length
ensures 0<=k<=i && s==Sum2(v,k,i+1) && SumMaxToRight2(v,0,i,s)
//Implement and verify
{
s:=v[i];
k:=i;
var j:=i;
var maxs:=s;
while(j>0)
{
s:=s+v[j-1];
if(s>maxs){
maxs:=s;
k:=j-1;
}
j:=j-1;
}
s:=maxs;
}
|
function Sum(v:array<int>,i:int,j:int):int
reads v
requires 0<=i<=j<=v.Length
decreases j
{
if (i==j) then 0
else Sum(v,i,j-1)+v[j-1]
}
predicate SumMaxToRight(v:array<int>,i:int,s:int)
reads v
requires 0<=i<v.Length
{
forall l,ss {:induction l}::0<=l<=i && ss==i+1==> Sum(v,l,ss)<=s
}
method segMaxSum(v:array<int>,i:int) returns (s:int,k:int)
requires v.Length>0 && 0<=i<v.Length
ensures 0<=k<=i && s==Sum(v,k,i+1) && SumMaxToRight(v,i,s)
{
s:=v[0];
k:=0;
var j:=0;
while (j<i)
decreases i-j
invariant 0<=j<=i
invariant 0<=k<=j && s==Sum(v,k,j+1)
invariant SumMaxToRight(v,j,s)
{
if (s+v[j+1]>v[j+1]) {s:=s+v[j+1];}
else {k:=j+1;s:=v[j+1];}
j:=j+1;
}
}
function Sum2(v:array<int>,i:int,j:int):int
reads v
requires 0<=i<=j<=v.Length
decreases j-i
{
if (i==j) then 0
else v[i]+Sum2(v,i+1,j)
}
//Now do the same but with a loop from right to left
predicate SumMaxToRight2(v:array<int>,j:int,i:int,s:int)//maximum sum stuck to the right
reads v
requires 0<=j<=i<v.Length
{(forall l,ss {:induction l}::j<=l<=i && ss==i+1 ==> Sum2(v,l,ss)<=s)}
method segSumaMaxima2(v:array<int>,i:int) returns (s:int,k:int)
requires v.Length>0 && 0<=i<v.Length
ensures 0<=k<=i && s==Sum2(v,k,i+1) && SumMaxToRight2(v,0,i,s)
//Implement and verify
{
s:=v[i];
k:=i;
var j:=i;
var maxs:=s;
while(j>0)
decreases j
invariant 0<=j<=i
invariant 0<=k<=i
invariant s==Sum2(v,j,i+1)
invariant SumMaxToRight2(v,j,i,maxs)
invariant maxs==Sum2(v,k,i+1)
{
s:=s+v[j-1];
if(s>maxs){
maxs:=s;
k:=j-1;
}
j:=j-1;
}
s:=maxs;
}
| Dafny-Exercises_tmp_tmpjm75muf__Session9Exercises_ExerciseSeqMaxSum.dfy | 67 |
/*
https://leetcode.com/problems/two-sum/
function twoSum(nums: number[], target: number): number[] {
const n = nums.length;
for(let i = 0; i < n; i++) {
for(let k = i+1; k < n; k++) {
if(nums[i] + nums[k] == target) return [i,k];
}
}
};
*/
predicate summingPair(i: nat, j: nat, nums: seq<int>, target: int)
requires i < |nums|
requires j < |nums|
{
i != j && nums[i] + nums[j] == target
}
method twoSum(nums: seq<int>, target: int) returns (pair: (nat, nat))
requires exists i:nat,j:nat :: i < j < |nums| && summingPair(i, j, nums, target) && forall l: nat, m: nat :: l < m < |nums| && l != i && m != j ==> !summingPair(l, m, nums, target)
ensures 0 <= pair.0 < |nums| && 0 <= pair.1 < |nums| && summingPair(pair.0, pair.1, nums, target)
{
pair := (0,0);
var i: nat := 0;
while i < |nums|
{
var k: nat := i + 1;
while k < |nums|
// invariant forall q: nat :: i+1 <= q < k < |nums| ==> !summingPair(i,q, nums, target) //this fails to verify
{
// assert i < k < |nums|;
if nums[i] + nums[k] == target {
pair := (i,k);
return pair;
}
k := k + 1;
}
i := i + 1;
}
}
| /*
https://leetcode.com/problems/two-sum/
function twoSum(nums: number[], target: number): number[] {
const n = nums.length;
for(let i = 0; i < n; i++) {
for(let k = i+1; k < n; k++) {
if(nums[i] + nums[k] == target) return [i,k];
}
}
};
*/
predicate summingPair(i: nat, j: nat, nums: seq<int>, target: int)
requires i < |nums|
requires j < |nums|
{
i != j && nums[i] + nums[j] == target
}
method twoSum(nums: seq<int>, target: int) returns (pair: (nat, nat))
requires exists i:nat,j:nat :: i < j < |nums| && summingPair(i, j, nums, target) && forall l: nat, m: nat :: l < m < |nums| && l != i && m != j ==> !summingPair(l, m, nums, target)
ensures 0 <= pair.0 < |nums| && 0 <= pair.1 < |nums| && summingPair(pair.0, pair.1, nums, target)
{
pair := (0,0);
var i: nat := 0;
while i < |nums|
invariant i <= |nums|
invariant forall z: nat, j: nat :: 0 <= z < i && z+1 <= j < |nums| ==> !summingPair(z, j, nums, target)
{
var k: nat := i + 1;
while k < |nums|
invariant i + 1 <= k <= |nums|
// invariant forall q: nat :: i+1 <= q < k < |nums| ==> !summingPair(i,q, nums, target) //this fails to verify
invariant forall q: nat :: i+1 <= q < k <= |nums| ==> !summingPair(i,q, nums, target) //this verifies
{
// assert i < k < |nums|;
if nums[i] + nums[k] == target {
pair := (i,k);
return pair;
}
k := k + 1;
}
i := i + 1;
}
}
| Dafny-Grind75_tmp_tmpsxfz3i4r_problems_twoSum.dfy | 68 |
datatype Tree = Empty | Node(int,Tree,Tree)
method Main() {
var tree := BuildBST([-2,8,3,9,2,-7,0]);
PrintTreeNumbersInorder(tree);
}
method PrintTreeNumbersInorder(t: Tree)
{
match t {
case Empty =>
case Node(n, l, r) =>
PrintTreeNumbersInorder(l);
print n;
print "\n";
PrintTreeNumbersInorder(r);
}
}
function NumbersInTree(t: Tree): set<int>
{
NumbersInSequence(Inorder(t))
}
function NumbersInSequence(q: seq<int>): set<int>
{
set x | x in q
}
predicate BST(t: Tree)
{
Ascending(Inorder(t))
}
function Inorder(t: Tree): seq<int>
{
match t {
case Empty => []
case Node(n',nt1,nt2) => Inorder(nt1)+[n']+Inorder(nt2)
}
}
predicate Ascending(q: seq<int>)
{
forall i,j :: 0 <= i < j < |q| ==> q[i] < q[j]
}
predicate NoDuplicates(q: seq<int>) { forall i,j :: 0 <= i < j < |q| ==> q[i] != q[j] }
/*
Goal: Implement correctly, clearly. No need to document the proof obligations.
*/
method BuildBST(q: seq<int>) returns (t: Tree)
requires NoDuplicates(q)
ensures BST(t) && NumbersInTree(t) == NumbersInSequence(q)
{
t := Empty;
for i:=0 to |q|
{
t := InsertBST(t,q[i]);
}
}
/*
Goal: Implement correctly, efficiently, clearly, documenting the proof obligations
as we've learned, with assertions and a lemma for each proof goal
*/
method InsertBST(t0: Tree, x: int) returns (t: Tree)
requires BST(t0) && x !in NumbersInTree(t0)
ensures BST(t) && NumbersInTree(t) == NumbersInTree(t0)+{x}
{
match t0
{
case Empty => t := Node(x, Empty, Empty);
case Node(i, left, right) =>
{
var tmp:Tree:= Empty;
if x < i
{
LemmaBinarySearchSubtree(i,left,right);
tmp := InsertBST(left, x);
t := Node(i, tmp, right);
ghost var right_nums := Inorder(right);
ghost var left_nums := Inorder(left);
ghost var all_nums := Inorder(t0);
// assert all_nums[..|left_nums|] == left_nums;
ghost var new_all_nums := Inorder(t);
ghost var new_left_nums := Inorder(tmp);
// assert Ascending(new_left_nums+ [i] + right_nums);
lemma_all_small(new_left_nums,i);
}
else
{
LemmaBinarySearchSubtree(i,left,right);
tmp := InsertBST(right, x);
t := Node(i, left, tmp);
ghost var right_nums := Inorder(right);
ghost var left_nums := Inorder(left);
ghost var all_nums := Inorder(t0);
// assert all_nums[..|left_nums|] == left_nums;
ghost var new_all_nums := Inorder(t);
ghost var new_right_nums := Inorder(tmp);
// assert Ascending(left_nums+ [i] + right_nums);
// assert forall j :: j in NumbersInSequence(all_nums[|left_nums|+1..]) ==> j > i;
// assert forall j :: j in NumbersInSequence(all_nums[|left_nums|+1..])+{x} ==> j > i;
lemma_all_big(new_right_nums,i);
// assert Ascending(new_right_nums+[i]);
}
}
}
}
lemma LemmaBinarySearchSubtree(n: int, left: Tree, right: Tree)
requires BST(Node(n, left, right))
ensures BST(left) && BST(right)
{
var qleft, qright := Inorder(left), Inorder(right);
var q := qleft+[n]+qright;
}
lemma LemmaAscendingSubsequence(q1: seq<int>, q2: seq<int>, i: nat)
requires i <= |q1|-|q2| && q2 == q1[i..i+|q2|]
requires Ascending(q1)
ensures Ascending(q2)
{}
lemma {:verify true} lemma_all_small(q:seq<int>,i:int)
requires forall k:: k in NumbersInSequence(q) ==> k < i
requires forall k:: 0 <= k < |q| ==> q[k] in NumbersInSequence(q)
ensures forall j::0<=j < |q| ==> q[j] < i
{}
lemma {:verify true} lemma_all_big(q:seq<int>,i:int)
requires forall k:: k in NumbersInSequence(q) ==> k > i
requires forall k:: 0 <= k < |q| ==> q[k] in NumbersInSequence(q)
ensures forall j::0<=j < |q| ==> q[j] > i
{}
| datatype Tree = Empty | Node(int,Tree,Tree)
method Main() {
var tree := BuildBST([-2,8,3,9,2,-7,0]);
PrintTreeNumbersInorder(tree);
}
method PrintTreeNumbersInorder(t: Tree)
{
match t {
case Empty =>
case Node(n, l, r) =>
PrintTreeNumbersInorder(l);
print n;
print "\n";
PrintTreeNumbersInorder(r);
}
}
function NumbersInTree(t: Tree): set<int>
{
NumbersInSequence(Inorder(t))
}
function NumbersInSequence(q: seq<int>): set<int>
{
set x | x in q
}
predicate BST(t: Tree)
{
Ascending(Inorder(t))
}
function Inorder(t: Tree): seq<int>
{
match t {
case Empty => []
case Node(n',nt1,nt2) => Inorder(nt1)+[n']+Inorder(nt2)
}
}
predicate Ascending(q: seq<int>)
{
forall i,j :: 0 <= i < j < |q| ==> q[i] < q[j]
}
predicate NoDuplicates(q: seq<int>) { forall i,j :: 0 <= i < j < |q| ==> q[i] != q[j] }
/*
Goal: Implement correctly, clearly. No need to document the proof obligations.
*/
method BuildBST(q: seq<int>) returns (t: Tree)
requires NoDuplicates(q)
ensures BST(t) && NumbersInTree(t) == NumbersInSequence(q)
{
t := Empty;
for i:=0 to |q|
invariant BST(t);
invariant NumbersInTree(t) == NumbersInSequence(q[..i])
{
t := InsertBST(t,q[i]);
}
}
/*
Goal: Implement correctly, efficiently, clearly, documenting the proof obligations
as we've learned, with assertions and a lemma for each proof goal
*/
method InsertBST(t0: Tree, x: int) returns (t: Tree)
requires BST(t0) && x !in NumbersInTree(t0)
ensures BST(t) && NumbersInTree(t) == NumbersInTree(t0)+{x}
{
match t0
{
case Empty => t := Node(x, Empty, Empty);
case Node(i, left, right) =>
{
var tmp:Tree:= Empty;
if x < i
{
LemmaBinarySearchSubtree(i,left,right);
tmp := InsertBST(left, x);
t := Node(i, tmp, right);
ghost var right_nums := Inorder(right);
ghost var left_nums := Inorder(left);
ghost var all_nums := Inorder(t0);
assert all_nums == left_nums + [i] + right_nums;
assert all_nums[|left_nums|] == i;
assert all_nums[|left_nums|+1..] == right_nums;
// assert all_nums[..|left_nums|] == left_nums;
assert Ascending(right_nums);
assert Ascending(left_nums);
assert Ascending(left_nums + [i] + right_nums);
assert forall j,k :: |left_nums| < j < k < |all_nums| ==> x < i < all_nums[j] < all_nums[k];
ghost var new_all_nums := Inorder(t);
ghost var new_left_nums := Inorder(tmp);
assert new_all_nums == (new_left_nums + [i] + right_nums);
assert Ascending([i]+right_nums);
assert Ascending(new_left_nums);
assert NumbersInSequence(new_left_nums) == NumbersInSequence(left_nums) + {x};
// assert Ascending(new_left_nums+ [i] + right_nums);
assert forall j,k::0<= j < k <|all_nums| ==> all_nums[j]<all_nums[k];
assert forall j,k::0<= j < k <|left_nums| ==> all_nums[j]<all_nums[k]<all_nums[|left_nums|];
assert all_nums[|left_nums|] == i;
assert left_nums == all_nums[..|left_nums|];
assert NumbersInSequence(new_left_nums) == NumbersInSequence(all_nums[..|left_nums|])+{x};
assert forall j,k::0<=j < k < |left_nums| ==> left_nums[j] < left_nums[k] < i;
assert x < i;
assert forall j :: j in NumbersInSequence(all_nums[..|left_nums|]) ==> j < i;
assert forall j :: j in NumbersInSequence(all_nums[..|left_nums|])+{x} ==> j < i;
assert forall j :: j in NumbersInSequence(new_left_nums) ==> j < i;
assert forall j :: j in NumbersInSequence(new_left_nums) <==> j in new_left_nums;
assert forall j,k::0<=j < k < |new_left_nums| ==> new_left_nums[j] < new_left_nums[k];
assert x < i;
lemma_all_small(new_left_nums,i);
assert forall j::0<=j < |new_left_nums| ==> new_left_nums[j] < i;
assert Ascending(new_left_nums+[i]);
assert Ascending(Inorder(t));
assert BST(t);
}
else
{
LemmaBinarySearchSubtree(i,left,right);
tmp := InsertBST(right, x);
t := Node(i, left, tmp);
ghost var right_nums := Inorder(right);
ghost var left_nums := Inorder(left);
ghost var all_nums := Inorder(t0);
assert all_nums == left_nums + [i] + right_nums;
assert all_nums[|left_nums|] == i;
assert all_nums[|left_nums|+1..] == right_nums;
// assert all_nums[..|left_nums|] == left_nums;
assert Ascending(right_nums);
assert Ascending(left_nums);
assert Ascending(left_nums + [i] + right_nums);
assert forall j,k :: 0 <= j < k < |left_nums| ==> all_nums[j] < all_nums[k] < i < x;
ghost var new_all_nums := Inorder(t);
ghost var new_right_nums := Inorder(tmp);
assert new_all_nums == (left_nums + [i] + new_right_nums);
assert Ascending(left_nums + [i]);
assert Ascending(new_right_nums);
assert NumbersInSequence(new_right_nums) == NumbersInSequence(right_nums) + {x};
// assert Ascending(left_nums+ [i] + right_nums);
assert forall j,k::0<= j < k <|all_nums| ==> all_nums[j]<all_nums[k];
assert forall j,k::|left_nums| < j < k < |all_nums|==> all_nums[|left_nums|]<all_nums[j]<all_nums[k];
assert all_nums[|left_nums|] == i;
assert left_nums == all_nums[..|left_nums|];
assert NumbersInSequence(new_right_nums) == NumbersInSequence(all_nums[|left_nums|+1..])+{x};
assert forall j,k::0<=j < k < |right_nums| ==> i < right_nums[j] < right_nums[k] ;
assert x > i;
// assert forall j :: j in NumbersInSequence(all_nums[|left_nums|+1..]) ==> j > i;
// assert forall j :: j in NumbersInSequence(all_nums[|left_nums|+1..])+{x} ==> j > i;
assert forall j :: j in NumbersInSequence(new_right_nums) ==> j > i;
assert forall j :: j in NumbersInSequence(new_right_nums) <==> j in new_right_nums;
assert forall j,k::0<=j < k < |new_right_nums| ==> new_right_nums[j] < new_right_nums[k];
assert x > i;
lemma_all_big(new_right_nums,i);
assert forall j::0<=j < |new_right_nums| ==> new_right_nums[j] > i;
// assert Ascending(new_right_nums+[i]);
assert Ascending(Inorder(t));
assert BST(t);
}
}
}
}
lemma LemmaBinarySearchSubtree(n: int, left: Tree, right: Tree)
requires BST(Node(n, left, right))
ensures BST(left) && BST(right)
{
assert Ascending(Inorder(Node(n, left, right)));
var qleft, qright := Inorder(left), Inorder(right);
var q := qleft+[n]+qright;
assert q == Inorder(Node(n, left, right));
assert Ascending(qleft+[n]+qright);
assert Ascending(qleft) by { LemmaAscendingSubsequence(q, qleft, 0); }
assert Ascending(qright) by { LemmaAscendingSubsequence(q, qright, |qleft|+1); }
}
lemma LemmaAscendingSubsequence(q1: seq<int>, q2: seq<int>, i: nat)
requires i <= |q1|-|q2| && q2 == q1[i..i+|q2|]
requires Ascending(q1)
ensures Ascending(q2)
{}
lemma {:verify true} lemma_all_small(q:seq<int>,i:int)
requires forall k:: k in NumbersInSequence(q) ==> k < i
requires forall k:: 0 <= k < |q| ==> q[k] in NumbersInSequence(q)
ensures forall j::0<=j < |q| ==> q[j] < i
{}
lemma {:verify true} lemma_all_big(q:seq<int>,i:int)
requires forall k:: k in NumbersInSequence(q) ==> k > i
requires forall k:: 0 <= k < |q| ==> q[k] in NumbersInSequence(q)
ensures forall j::0<=j < |q| ==> q[j] > i
{}
| Dafny-Practice_tmp_tmphnmt4ovh_BST.dfy | 69 |
method {:verify true} FindAllOccurrences(text: string, pattern: string) returns (offsets: set<nat>)
ensures forall i :: i in offsets ==> i + |pattern| <= |text|
ensures forall i :: 0 <= i <= |text| - |pattern| ==> (text[i..i+|pattern|] == pattern <==> i in offsets)
{
offsets := {};
var i:int := 0;
// no pattern in text at all.
if |pattern| > |text|
{
return offsets;
}
//all offsets are offsets of pattern/
if pattern == ""
{
while i < |text|
{
offsets := offsets + {i};
i:=i+1;
}
offsets := offsets + {|text|};
return offsets;
}
var pattern_hash: int := RecursiveSumDown(pattern);
var text_hash: int := RecursiveSumDown(text[..|pattern|]);
if pattern_hash == text_hash{
if text[..|pattern|] == pattern
{
offsets := offsets + {0};
}
}
else
{
LemmaRabinKarp(text[..|pattern|], pattern, text_hash, pattern_hash);
}
while i < |text| - |pattern|
{
//updating text hash
var old_text_hash := text_hash;
var left_letter_as_int := text[i] as int;
var right_new_letter_as_int := text[i+|pattern|] as int;
text_hash := text_hash - left_letter_as_int + right_new_letter_as_int;
//updating i
i := i + 1;
//checking hash equality
if pattern_hash == text_hash{
if text[i..i + |pattern|] == pattern
{
offsets := offsets + {i};
}
LemmaHashEqualty(text_hash, text, i, old_text_hash, pattern);
}
else{
LemmaHashEqualty(text_hash, text, i, old_text_hash, pattern);
LemmaRabinKarp(text[i..i+|pattern|], pattern, text_hash, pattern_hash);
}
Lemma2Sides(text, pattern, i, offsets);
//=>
//=>
}
//=>
}
function RecursiveSumDown(str: string): int
{
if str == "" then 0 else str[|str|-1] as int +RecursiveSumDown(str[..|str|-1])
}
function RecursiveSumUp(str: string): int
{
if str == "" then 0 else str[0] as int + RecursiveSumUp(str[1..])
}
lemma {:verify true}LemmaRabinKarp(t_sub:string, pattern:string, text_hash:int, pattern_hash:int)
requires text_hash != pattern_hash
requires pattern_hash == RecursiveSumDown(pattern)
requires text_hash == RecursiveSumDown(t_sub)
ensures t_sub[..] != pattern[..]
{}
lemma Lemma2Sides(text: string, pattern: string, i: nat, offsets: set<nat>)
requires 0 <= i <= |text| - |pattern|
requires (text[i..i+|pattern|] == pattern ==> i in offsets)
requires (text[i..i+|pattern|] == pattern <== i in offsets)
ensures (text[i..i+|pattern|] == pattern <==> i in offsets)
{}
lemma LemmaHashEqualty(text_hash : int, text: string, i: nat, old_text_hash: int, pattern: string)
requires 0 < i <= |text| - |pattern|
requires text_hash == old_text_hash - text[i - 1] as int + text[i - 1 + |pattern|] as int
requires old_text_hash == RecursiveSumDown(text[i - 1..i - 1 + |pattern|]);
ensures text_hash == RecursiveSumDown(text[i..i+|pattern|])
{
ghost var temp_val := old_text_hash + text[i - 1 + |pattern|] as int;
//=>
ghost var str := text[i - 1..];
LemmaAddingOneIndex(str, |pattern|, old_text_hash);
//=>
//=>
PrependSumUp(text[i - 1..i + |pattern|]);
EquivalentSumDefinitions(text[i - 1..i + |pattern|]);
EquivalentSumDefinitions(text[i..i + |pattern|]);
//=>
//=>
//=>
//=>
}
lemma LemmaAddingOneIndex(str: string, i: nat, sum: int)
requires 0 <= i < |str| && sum == RecursiveSumDown(str[..i])
ensures 0 <= i+1 <= |str| && sum + str[i] as int == RecursiveSumDown(str[..i+1])
{
var str1 := str[..i+1];
calc {
RecursiveSumDown(str[..i+1]);
== // def.
if str1 == [] then 0 else str1[|str1|-1] as int + RecursiveSumDown(str1[..|str1|-1]);
== { assert str1 != []; } // simplification for a non-empty sequence
str1[|str1|-1] as int + RecursiveSumDown(str1[..|str1|-1]);
== { assert |str1|-1 == i; }
str1[i] as int + RecursiveSumDown(str1[..i]);
== { assert str1[..i] == str[..i]; }
str[i] as int + RecursiveSumDown(str[..i]);
== // inv.
str[i] as int + sum;
==
sum + str[i] as int;
}
}
lemma PrependSumUp(str: string)
requires str != ""
ensures RecursiveSumUp(str) == str[0] as int + RecursiveSumUp(str[1..])
{
// directly from the definition of RecursiveSumUp (for a non-emty sequence)
}
lemma EquivalentSumDefinitions(str: string)
ensures RecursiveSumDown(str) == RecursiveSumUp(str)
{
if |str| == 0
{
}
else if |str| == 1
{
}
else
{
var first: char, mid: string, last:char := str[0], str[1..|str|-1], str[|str|-1];
calc {
RecursiveSumDown(str);
== { assert str != [] && str[|str|-1] == last && str[..|str|-1] == [first] + mid; }
last as int + RecursiveSumDown([first] + mid);
== // arithmetic
RecursiveSumDown([first] + mid) + last as int;
== { EquivalentSumDefinitions([first] + mid); } // induction hypothesis
RecursiveSumUp([first] + mid) + last as int;
== { assert [first] + mid != []; }
first as int + RecursiveSumUp(mid) + last as int;
== { EquivalentSumDefinitions(mid); } // induction hypothesis
first as int + RecursiveSumDown(mid) + last as int;
==
first as int + RecursiveSumDown(mid + [last]);
== { EquivalentSumDefinitions(mid + [last]); } // induction hypothesis
first as int + RecursiveSumUp(mid + [last]);
== { assert str != [] && str[0] == first && str[1..] == mid + [last]; }
RecursiveSumUp(str);
}
}
}
|
method {:verify true} FindAllOccurrences(text: string, pattern: string) returns (offsets: set<nat>)
ensures forall i :: i in offsets ==> i + |pattern| <= |text|
ensures forall i :: 0 <= i <= |text| - |pattern| ==> (text[i..i+|pattern|] == pattern <==> i in offsets)
{
offsets := {};
var i:int := 0;
// no pattern in text at all.
if |pattern| > |text|
{
assert forall i :: i in offsets ==> i + |pattern| <= |text|;
assert forall i :: 0 <= i <= |text| - |pattern| ==> (text[i..i+|pattern|] == pattern <==> i in offsets);
return offsets;
}
//all offsets are offsets of pattern/
if pattern == ""
{
while i < |text|
invariant 0 <= i <=|text|
invariant forall j :: 0 <= j < i ==> (text[j..j+|pattern|] == pattern <==> j in offsets)
invariant forall j :: j in offsets ==> j + |pattern| <= |text|
{
offsets := offsets + {i};
i:=i+1;
}
offsets := offsets + {|text|};
assert forall i :: i in offsets ==> i + |pattern| <= |text|;
assert forall i :: 0 <= i <= |text| - |pattern| ==> (text[i..i+|pattern|] == pattern <==> i in offsets);
return offsets;
}
var pattern_hash: int := RecursiveSumDown(pattern);
var text_hash: int := RecursiveSumDown(text[..|pattern|]);
assert text_hash == RecursiveSumDown(text[..|pattern|]);
if pattern_hash == text_hash{
if text[..|pattern|] == pattern
{
offsets := offsets + {0};
}
}
else
{
LemmaRabinKarp(text[..|pattern|], pattern, text_hash, pattern_hash);
}
while i < |text| - |pattern|
invariant 0 <= i <= |text| - |pattern|
invariant text_hash == RecursiveSumDown(text[i..i + |pattern|])
invariant forall k :: 0 <= k <= i ==> (text[k..k+|pattern|] == pattern <==> k in offsets)
invariant forall i :: i in offsets ==> i + |pattern| <= |text|
invariant forall k :: i < k ==> (k in offsets) == false
decreases |text| - |pattern| - i
{
assert text_hash == RecursiveSumDown(text[i..i + |pattern|]);
assert forall k :: 0 <= k <= i ==> (text[k..k+|pattern|] == pattern <==> k in offsets);
//updating text hash
var old_text_hash := text_hash;
assert old_text_hash == RecursiveSumDown(text[i..i + |pattern|]);
var left_letter_as_int := text[i] as int;
var right_new_letter_as_int := text[i+|pattern|] as int;
text_hash := text_hash - left_letter_as_int + right_new_letter_as_int;
//updating i
assert forall k :: 0 <= k <= i ==> (text[k..k+|pattern|] == pattern <==> k in offsets);
assert text_hash == old_text_hash - text[i] as int + text[i+|pattern|] as int;
assert old_text_hash == RecursiveSumDown(text[i..i + |pattern|]);
i := i + 1;
assert old_text_hash == RecursiveSumDown(text[i - 1..i - 1 + |pattern|]);
assert forall k :: 0 <= k < i ==> (text[k..k+|pattern|] == pattern <==> k in offsets);
assert text_hash == old_text_hash - text[i - 1] as int + text[i - 1 + |pattern|] as int;
//checking hash equality
if pattern_hash == text_hash{
if text[i..i + |pattern|] == pattern
{
assert (text[i..i + |pattern|] == pattern);
offsets := offsets + {i};
assert (i in offsets);
assert text[i..i+|pattern|] == pattern <== i in offsets;
assert text[i..i+|pattern|] == pattern ==> i in offsets;
}
assert pattern_hash == RecursiveSumDown(pattern);
assert text_hash == old_text_hash - text[i - 1] as int + text[i - 1 + |pattern|] as int;
assert old_text_hash == RecursiveSumDown(text[i - 1..i - 1 + |pattern|]);
LemmaHashEqualty(text_hash, text, i, old_text_hash, pattern);
assert text_hash == RecursiveSumDown(text[i..i+|pattern|]);
}
else{
assert text_hash != pattern_hash;
assert pattern_hash == RecursiveSumDown(pattern);
assert text_hash == old_text_hash - text[i - 1] as int + text[i - 1 + |pattern|] as int;
assert old_text_hash == RecursiveSumDown(text[i - 1..i - 1 + |pattern|]);
LemmaHashEqualty(text_hash, text, i, old_text_hash, pattern);
assert text_hash == RecursiveSumDown(text[i..i+|pattern|]);
LemmaRabinKarp(text[i..i+|pattern|], pattern, text_hash, pattern_hash);
assert text[i..i+|pattern|] == pattern ==> i in offsets;
assert (i in offsets) == false;
assert text[i..i+|pattern|] == pattern <== i in offsets;
}
assert text[i..i+|pattern|] == pattern ==> i in offsets;
assert text[i..i+|pattern|] == pattern <== i in offsets;
Lemma2Sides(text, pattern, i, offsets);
//=>
assert text[i..i+|pattern|] == pattern <==> i in offsets;
assert forall k :: 0 <= k < i ==> (text[k..k+|pattern|] == pattern <==> k in offsets);
//=>
assert forall k :: 0 <= k <= i ==> (text[k..k+|pattern|] == pattern <==> k in offsets);
assert text_hash == RecursiveSumDown(text[i..i+|pattern|]);
}
assert 0 <= i <= |text| - |pattern|;
assert forall i :: i in offsets ==> i + |pattern| <= |text|;
assert forall k :: i < k ==> (k in offsets) == false;
assert forall k :: 0 <= k <= i ==> (text[k..k+|pattern|] == pattern <==> k in offsets);
assert i >= |text| - |pattern|;
//=>
assert forall i :: 0 <= i <= |text| - |pattern| ==> (text[i..i+|pattern|] == pattern <==> i in offsets);
assert forall i :: i in offsets ==> i + |pattern| <= |text|;
assert forall i :: 0 <= i <= |text| - |pattern| ==> (text[i..i+|pattern|] == pattern <==> i in offsets);
}
function RecursiveSumDown(str: string): int
decreases |str|
{
if str == "" then 0 else str[|str|-1] as int +RecursiveSumDown(str[..|str|-1])
}
function RecursiveSumUp(str: string): int
decreases |str|
{
if str == "" then 0 else str[0] as int + RecursiveSumUp(str[1..])
}
lemma {:verify true}LemmaRabinKarp(t_sub:string, pattern:string, text_hash:int, pattern_hash:int)
requires text_hash != pattern_hash
requires pattern_hash == RecursiveSumDown(pattern)
requires text_hash == RecursiveSumDown(t_sub)
ensures t_sub[..] != pattern[..]
{}
lemma Lemma2Sides(text: string, pattern: string, i: nat, offsets: set<nat>)
requires 0 <= i <= |text| - |pattern|
requires (text[i..i+|pattern|] == pattern ==> i in offsets)
requires (text[i..i+|pattern|] == pattern <== i in offsets)
ensures (text[i..i+|pattern|] == pattern <==> i in offsets)
{}
lemma LemmaHashEqualty(text_hash : int, text: string, i: nat, old_text_hash: int, pattern: string)
requires 0 < i <= |text| - |pattern|
requires text_hash == old_text_hash - text[i - 1] as int + text[i - 1 + |pattern|] as int
requires old_text_hash == RecursiveSumDown(text[i - 1..i - 1 + |pattern|]);
ensures text_hash == RecursiveSumDown(text[i..i+|pattern|])
{
assert 0 < i <= |text| - |pattern|;
assert 0 <= i - 1 < |text| - |pattern|;
ghost var temp_val := old_text_hash + text[i - 1 + |pattern|] as int;
assert text_hash == old_text_hash + text[i - 1 + |pattern|] as int - text[i - 1] as int;
//=>
assert text_hash == temp_val - text[i - 1] as int;
assert 0 <= |pattern| < |text[i - 1..]|;
ghost var str := text[i - 1..];
assert str[..|pattern|] == text[i - 1 .. i - 1 + |pattern|];
assert old_text_hash == RecursiveSumDown(str[..|pattern|]);
LemmaAddingOneIndex(str, |pattern|, old_text_hash);
assert old_text_hash + str[|pattern|] as int == RecursiveSumDown(str[..|pattern|+1]);
assert str[..|pattern|+1] == text[i - 1..i - 1 + |pattern| + 1];
//=>
assert old_text_hash + text[i - 1 + |pattern|] as int == RecursiveSumDown(text[i - 1..i - 1 + |pattern| + 1]);
assert temp_val == old_text_hash + text[i - 1 + |pattern|] as int;
//=>
assert temp_val == RecursiveSumDown(text[i - 1..i - 1 + |pattern| + 1]);
assert temp_val == RecursiveSumDown(text[i - 1..i + |pattern|]);
PrependSumUp(text[i - 1..i + |pattern|]);
assert RecursiveSumUp(text[i - 1..i + |pattern|]) == text[i - 1] as int + RecursiveSumUp(text[i..i + |pattern|]);
EquivalentSumDefinitions(text[i - 1..i + |pattern|]);
EquivalentSumDefinitions(text[i..i + |pattern|]);
//=>
assert RecursiveSumUp(text[i - 1..i + |pattern|]) == RecursiveSumDown(text[i - 1..i + |pattern|]);
assert RecursiveSumUp(text[i..i + |pattern|]) == RecursiveSumDown(text[i..i + |pattern|]);
//=>
assert RecursiveSumDown(text[i - 1..i + |pattern|]) == text[i - 1] as int + RecursiveSumDown(text[i..i + |pattern|]);
//=>
assert RecursiveSumDown(text[i - 1..i + |pattern|]) - text[i - 1] as int == RecursiveSumDown(text[i..i + |pattern|]);
assert text_hash == temp_val - text[i - 1] as int;
assert temp_val == RecursiveSumDown(text[i - 1..i + |pattern|]);
assert text_hash == RecursiveSumDown(text[i - 1..i + |pattern|]) - text[i - 1] as int;
//=>
assert text_hash == RecursiveSumDown(text[i..i + |pattern|]);
}
lemma LemmaAddingOneIndex(str: string, i: nat, sum: int)
requires 0 <= i < |str| && sum == RecursiveSumDown(str[..i])
ensures 0 <= i+1 <= |str| && sum + str[i] as int == RecursiveSumDown(str[..i+1])
{
var str1 := str[..i+1];
calc {
RecursiveSumDown(str[..i+1]);
== // def.
if str1 == [] then 0 else str1[|str1|-1] as int + RecursiveSumDown(str1[..|str1|-1]);
== { assert str1 != []; } // simplification for a non-empty sequence
str1[|str1|-1] as int + RecursiveSumDown(str1[..|str1|-1]);
== { assert |str1|-1 == i; }
str1[i] as int + RecursiveSumDown(str1[..i]);
== { assert str1[..i] == str[..i]; }
str[i] as int + RecursiveSumDown(str[..i]);
== // inv.
str[i] as int + sum;
==
sum + str[i] as int;
}
}
lemma PrependSumUp(str: string)
requires str != ""
ensures RecursiveSumUp(str) == str[0] as int + RecursiveSumUp(str[1..])
{
// directly from the definition of RecursiveSumUp (for a non-emty sequence)
}
lemma EquivalentSumDefinitions(str: string)
ensures RecursiveSumDown(str) == RecursiveSumUp(str)
decreases |str|
{
if |str| == 0
{
assert str == "";
assert RecursiveSumDown([]) == 0 == RecursiveSumUp([]);
}
else if |str| == 1
{
assert str == [str[0]];
assert RecursiveSumDown(str) == str[0] as int == RecursiveSumUp(str);
}
else
{
assert |str| >= 2;
var first: char, mid: string, last:char := str[0], str[1..|str|-1], str[|str|-1];
assert str == [first] + mid + [last];
calc {
RecursiveSumDown(str);
== { assert str != [] && str[|str|-1] == last && str[..|str|-1] == [first] + mid; }
last as int + RecursiveSumDown([first] + mid);
== // arithmetic
RecursiveSumDown([first] + mid) + last as int;
== { EquivalentSumDefinitions([first] + mid); } // induction hypothesis
RecursiveSumUp([first] + mid) + last as int;
== { assert [first] + mid != []; }
first as int + RecursiveSumUp(mid) + last as int;
== { EquivalentSumDefinitions(mid); } // induction hypothesis
first as int + RecursiveSumDown(mid) + last as int;
==
first as int + RecursiveSumDown(mid + [last]);
== { EquivalentSumDefinitions(mid + [last]); } // induction hypothesis
first as int + RecursiveSumUp(mid + [last]);
== { assert str != [] && str[0] == first && str[1..] == mid + [last]; }
RecursiveSumUp(str);
}
}
}
| Dafny-Practice_tmp_tmphnmt4ovh_Pattern Matching.dfy | 70 |
method ArraySplit (a : array<int>) returns (b : array<int>, c : array<int>)
ensures fresh(b)
ensures fresh(c)
ensures a[..] == b[..] + c[..]
ensures a.Length == b.Length + c.Length
ensures a.Length > 1 ==> a.Length > b.Length
ensures a.Length > 1 ==> a.Length > c.Length
{
var splitPoint : int := a.Length / 2;
b := new int[splitPoint];
c := new int[a.Length - splitPoint];
var i : int := 0;
while (i < splitPoint)
{
b[i] := a[i];
i := i + 1;
}
// while(i < a.Length)
// invariant splitPoint <= i <= a.Length
// invariant c[..i-splitPoint] == a[..i]
// {
// c[i] := a[i];
// i := i+1;
// }
var j : int := 0;
while (i < a.Length)
{
c[j] := a[i];
i := i + 1;
j := j + 1;
}
}
| method ArraySplit (a : array<int>) returns (b : array<int>, c : array<int>)
ensures fresh(b)
ensures fresh(c)
ensures a[..] == b[..] + c[..]
ensures a.Length == b.Length + c.Length
ensures a.Length > 1 ==> a.Length > b.Length
ensures a.Length > 1 ==> a.Length > c.Length
{
var splitPoint : int := a.Length / 2;
b := new int[splitPoint];
c := new int[a.Length - splitPoint];
var i : int := 0;
while (i < splitPoint)
invariant 0 <= i <= splitPoint
invariant b[..i] == a[..i]
{
b[i] := a[i];
i := i + 1;
}
// while(i < a.Length)
// invariant splitPoint <= i <= a.Length
// invariant c[..i-splitPoint] == a[..i]
// {
// c[i] := a[i];
// i := i+1;
// }
var j : int := 0;
while (i < a.Length)
invariant splitPoint <= i <= a.Length
invariant j == i - splitPoint
invariant c[..j] == a[splitPoint..i]
invariant b[..] + c[..j] == a[..i]
{
c[j] := a[i];
i := i + 1;
j := j + 1;
}
}
| Dafny-Projects_tmp_tmph399drhy_p2_arraySplit.dfy | 71 |
/*******************************************************************************
* Copyright by the contributors to the Dafny Project
* SPDX-License-Identifier: MIT
*******************************************************************************/
module Helper {
/************
Definitions
************/
function Power(b: nat, n: nat): (p: nat)
ensures b > 0 ==> p > 0
{
match n
case 0 => 1
case 1 => b
case _ => b * Power(b, n - 1)
}
function Log2Floor(n: nat): nat
requires n >= 1
{
if n < 2
then 0
else Log2Floor(n / 2) + 1
}
lemma Log2FloorDef(n: nat)
requires n >= 1
ensures Log2Floor(2 * n) == Log2Floor(n) + 1
{}
function boolToNat(b: bool): nat {
if b then 1 else 0
}
/*******
Lemmas
*******/
lemma Congruence<T, U>(x: T, y: T, f: T -> U)
requires x == y
ensures f(x) == f(y)
{}
lemma DivisionSubstituteAlternativeReal(x: real, a: real, b: real)
requires a == b
requires x != 0.0
ensures a / x == b / x
{}
lemma DivModAddDenominator(n: nat, m: nat)
requires m > 0
ensures (n + m) / m == n / m + 1
ensures (n + m) % m == n % m
{
var zp := (n + m) / m - n / m - 1;
}
lemma DivModIsUnique(n: int, m: int, a: int, b: int)
requires n >= 0
requires m > 0
requires 0 <= b < m
requires n == a * m + b
ensures a == n / m
ensures b == n % m
{
if a == 0 {
} else {
}
}
lemma DivModAddMultiple(a: nat, b: nat, c: nat)
requires a > 0
ensures (c * a + b) / a == c + b / a
ensures (c * a + b) % a == b % a
{
calc {
a * c + b;
==
a * c + (a * (b / a) + b % a);
==
a * (c + b / a) + b % a;
}
DivModIsUnique(a * c + b, a, c + b / a, b % a);
}
lemma DivisionByTwo(x: real)
ensures 0.5 * x == x / 2.0
{}
lemma PowerGreater0(base: nat, exponent: nat)
requires base >= 1
ensures Power(base, exponent) >= 1
{}
lemma Power2OfLog2Floor(n: nat)
requires n >= 1
ensures Power(2, Log2Floor(n)) <= n < Power(2, Log2Floor(n) + 1)
{}
lemma NLtPower2Log2FloorOf2N(n: nat)
requires n >= 1
ensures n < Power(2, Log2Floor(2 * n))
{
calc {
n;
< { Power2OfLog2Floor(n); }
Power(2, Log2Floor(n) + 1);
== { Log2FloorDef(n); }
Power(2, Log2Floor(2 * n));
}
}
lemma MulMonotonic(a: nat, b: nat, c: nat, d: nat)
requires a <= c
requires b <= d
ensures a * b <= c * d
{
calc {
a * b;
<=
c * b;
<=
c * d;
}
}
lemma MulMonotonicStrictRhs(b: nat, c: nat, d: nat)
requires b < d
requires c > 0
ensures c * b < c * d
{}
lemma MulMonotonicStrict(a: nat, b: nat, c: nat, d: nat)
requires a <= c
requires b <= d
requires (a != c && d > 0) || (b != d && c > 0)
ensures a * b < c * d
{
if a != c && d > 0 {
calc {
a * b;
<= { MulMonotonic(a, b, a, d); }
a * d;
<
c * d;
}
}
if b != d && c > 0 {
calc {
a * b;
<=
c * b;
< { MulMonotonicStrictRhs(b, c, d); }
c * d;
}
}
}
lemma AdditionOfFractions(x: real, y: real, z: real)
requires z != 0.0
ensures (x / z) + (y / z) == (x + y) / z
{}
lemma DivSubstituteDividend(x: real, y: real, z: real)
requires y != 0.0
requires x == z
ensures x / y == z / y
{}
lemma DivSubstituteDivisor(x: real, y: real, z: real)
requires y != 0.0
requires y == z
ensures x / y == x / z
{}
lemma DivDivToDivMul(x: real, y: real, z: real)
requires y != 0.0
requires z != 0.0
ensures (x / y) / z == x / (y * z)
{}
lemma NatMulNatToReal(x: nat, y: nat)
ensures (x * y) as real == (x as real) * (y as real)
{}
lemma SimplifyFractions(x: real, y: real, z: real)
requires z != 0.0
requires y != 0.0
ensures (x / z) / (y / z) == x / y
{}
lemma PowerOfTwoLemma(k: nat)
ensures (1.0 / Power(2, k) as real) / 2.0 == 1.0 / (Power(2, k + 1) as real)
{
calc {
(1.0 / Power(2, k) as real) / 2.0;
== { DivDivToDivMul(1.0, Power(2, k) as real, 2.0); }
1.0 / (Power(2, k) as real * 2.0);
== { NatMulNatToReal(Power(2, k), 2); }
1.0 / (Power(2, k) * 2) as real;
==
1.0 / (Power(2, k + 1) as real);
}
}
}
| /*******************************************************************************
* Copyright by the contributors to the Dafny Project
* SPDX-License-Identifier: MIT
*******************************************************************************/
module Helper {
/************
Definitions
************/
function Power(b: nat, n: nat): (p: nat)
ensures b > 0 ==> p > 0
{
match n
case 0 => 1
case 1 => b
case _ => b * Power(b, n - 1)
}
function Log2Floor(n: nat): nat
requires n >= 1
decreases n
{
if n < 2
then 0
else Log2Floor(n / 2) + 1
}
lemma Log2FloorDef(n: nat)
requires n >= 1
ensures Log2Floor(2 * n) == Log2Floor(n) + 1
{}
function boolToNat(b: bool): nat {
if b then 1 else 0
}
/*******
Lemmas
*******/
lemma Congruence<T, U>(x: T, y: T, f: T -> U)
requires x == y
ensures f(x) == f(y)
{}
lemma DivisionSubstituteAlternativeReal(x: real, a: real, b: real)
requires a == b
requires x != 0.0
ensures a / x == b / x
{}
lemma DivModAddDenominator(n: nat, m: nat)
requires m > 0
ensures (n + m) / m == n / m + 1
ensures (n + m) % m == n % m
{
var zp := (n + m) / m - n / m - 1;
assert 0 == m * zp + ((n + m) % m) - (n % m);
}
lemma DivModIsUnique(n: int, m: int, a: int, b: int)
requires n >= 0
requires m > 0
requires 0 <= b < m
requires n == a * m + b
ensures a == n / m
ensures b == n % m
{
if a == 0 {
assert n == b;
} else {
assert (n - m) / m == a - 1 && (n - m) % m == b by { DivModIsUnique(n - m, m, a - 1, b); }
assert n / m == a && n % m == b by { DivModAddDenominator(n - m, m); }
}
}
lemma DivModAddMultiple(a: nat, b: nat, c: nat)
requires a > 0
ensures (c * a + b) / a == c + b / a
ensures (c * a + b) % a == b % a
{
calc {
a * c + b;
==
a * c + (a * (b / a) + b % a);
==
a * (c + b / a) + b % a;
}
DivModIsUnique(a * c + b, a, c + b / a, b % a);
}
lemma DivisionByTwo(x: real)
ensures 0.5 * x == x / 2.0
{}
lemma PowerGreater0(base: nat, exponent: nat)
requires base >= 1
ensures Power(base, exponent) >= 1
{}
lemma Power2OfLog2Floor(n: nat)
requires n >= 1
ensures Power(2, Log2Floor(n)) <= n < Power(2, Log2Floor(n) + 1)
{}
lemma NLtPower2Log2FloorOf2N(n: nat)
requires n >= 1
ensures n < Power(2, Log2Floor(2 * n))
{
calc {
n;
< { Power2OfLog2Floor(n); }
Power(2, Log2Floor(n) + 1);
== { Log2FloorDef(n); }
Power(2, Log2Floor(2 * n));
}
}
lemma MulMonotonic(a: nat, b: nat, c: nat, d: nat)
requires a <= c
requires b <= d
ensures a * b <= c * d
{
calc {
a * b;
<=
c * b;
<=
c * d;
}
}
lemma MulMonotonicStrictRhs(b: nat, c: nat, d: nat)
requires b < d
requires c > 0
ensures c * b < c * d
{}
lemma MulMonotonicStrict(a: nat, b: nat, c: nat, d: nat)
requires a <= c
requires b <= d
requires (a != c && d > 0) || (b != d && c > 0)
ensures a * b < c * d
{
if a != c && d > 0 {
calc {
a * b;
<= { MulMonotonic(a, b, a, d); }
a * d;
<
c * d;
}
}
if b != d && c > 0 {
calc {
a * b;
<=
c * b;
< { MulMonotonicStrictRhs(b, c, d); }
c * d;
}
}
}
lemma AdditionOfFractions(x: real, y: real, z: real)
requires z != 0.0
ensures (x / z) + (y / z) == (x + y) / z
{}
lemma DivSubstituteDividend(x: real, y: real, z: real)
requires y != 0.0
requires x == z
ensures x / y == z / y
{}
lemma DivSubstituteDivisor(x: real, y: real, z: real)
requires y != 0.0
requires y == z
ensures x / y == x / z
{}
lemma DivDivToDivMul(x: real, y: real, z: real)
requires y != 0.0
requires z != 0.0
ensures (x / y) / z == x / (y * z)
{}
lemma NatMulNatToReal(x: nat, y: nat)
ensures (x * y) as real == (x as real) * (y as real)
{}
lemma SimplifyFractions(x: real, y: real, z: real)
requires z != 0.0
requires y != 0.0
ensures (x / z) / (y / z) == x / y
{}
lemma PowerOfTwoLemma(k: nat)
ensures (1.0 / Power(2, k) as real) / 2.0 == 1.0 / (Power(2, k + 1) as real)
{
calc {
(1.0 / Power(2, k) as real) / 2.0;
== { DivDivToDivMul(1.0, Power(2, k) as real, 2.0); }
1.0 / (Power(2, k) as real * 2.0);
== { NatMulNatToReal(Power(2, k), 2); }
1.0 / (Power(2, k) * 2) as real;
==
1.0 / (Power(2, k + 1) as real);
}
}
}
| Dafny-VMC_tmp_tmpzgqv0i1u_src_Math_Helper.dfy | 72 |
method FindMax(a: array<int>) returns (i: int)
// Annotate this method with pre- and postconditions
// that ensure it behaves as described.
requires a.Length > 0
ensures 0<= i < a.Length
ensures forall k :: 0 <= k < a.Length ==> a[k] <= a[i]
{
// Fill in the body that calculates the INDEX of the maximum.
i := 0;
var index := 1;
while index < a.Length
{
if a[index] > a[i] {i:= index;}
index := index + 1;
}
}
| method FindMax(a: array<int>) returns (i: int)
// Annotate this method with pre- and postconditions
// that ensure it behaves as described.
requires a.Length > 0
ensures 0<= i < a.Length
ensures forall k :: 0 <= k < a.Length ==> a[k] <= a[i]
{
// Fill in the body that calculates the INDEX of the maximum.
i := 0;
var index := 1;
while index < a.Length
invariant 0 < index <= a.Length
invariant 0 <= i < index
invariant forall k :: 0 <= k < index ==> a[k] <= a[i]
{
if a[index] > a[i] {i:= index;}
index := index + 1;
}
}
| Dafny-experiences_tmp_tmp150sm9qy_dafny_started_tutorial_dafny_tutorial_array.dfy | 73 |
/*
Bubble Sort is the simplest sorting algorithm that works by
repeatedly swapping the adjacent elements if they are in wrong order.
*/
predicate sorted_between(A:array<int>, from:int, to:int)
reads A
{
forall i, j :: 0 <= i <= j < A.Length && from <= i <= j <= to ==> A[i] <= A[j]
}
predicate sorted(A:array<int>)
reads A
{
sorted_between(A, 0, A.Length-1)
}
method BubbleSort(A:array<int>)
modifies A
ensures sorted(A)
ensures multiset(A[..]) == multiset(old(A[..]))
{
var N := A.Length;
var i := N-1;
while 0 < i
{
print A[..], "\n";
var j := 0;
while j < i
{
if A[j] > A[j+1]
{
A[j], A[j+1] := A[j+1], A[j];
print A[..], "\n";
}
j := j+1;
}
i := i-1;
print "\n";
}
}
method Main() {
var A := new int[10];
A[0], A[1], A[2], A[3], A[4], A[5], A[6], A[7], A[8], A[9] := 2, 4, 6, 15, 3, 19, 17, 16, 18, 1;
BubbleSort(A);
print A[..];
}
/* Explanation:
// A is ordered for each pair of elements such that
// the first element belongs to the left partition of i
// and the second element belongs to the right partition of i
// There is a variable defined by the value that the array takes at position j
// Therefore, each value that the array takes for all elements from 0 to j
// They are less than or equal to the value of the variable
*/
| /*
Bubble Sort is the simplest sorting algorithm that works by
repeatedly swapping the adjacent elements if they are in wrong order.
*/
predicate sorted_between(A:array<int>, from:int, to:int)
reads A
{
forall i, j :: 0 <= i <= j < A.Length && from <= i <= j <= to ==> A[i] <= A[j]
}
predicate sorted(A:array<int>)
reads A
{
sorted_between(A, 0, A.Length-1)
}
method BubbleSort(A:array<int>)
modifies A
ensures sorted(A)
ensures multiset(A[..]) == multiset(old(A[..]))
{
var N := A.Length;
var i := N-1;
while 0 < i
invariant multiset(A[..]) == multiset(old(A[..]))
invariant sorted_between(A, i, N-1)
invariant forall n, m :: 0 <= n <= i < m < N ==> A[n] <= A[m]
decreases i
{
print A[..], "\n";
var j := 0;
while j < i
invariant 0 < i < N
invariant 0 <= j <= i
invariant multiset(A[..]) == multiset(old(A[..]))
invariant sorted_between(A, i, N-1)
invariant forall n, m :: 0 <= n <= i < m < N ==> A[n] <= A[m]
invariant forall n :: 0 <= n <= j ==> A[n] <= A[j]
decreases i - j
{
if A[j] > A[j+1]
{
A[j], A[j+1] := A[j+1], A[j];
print A[..], "\n";
}
j := j+1;
}
i := i-1;
print "\n";
}
}
method Main() {
var A := new int[10];
A[0], A[1], A[2], A[3], A[4], A[5], A[6], A[7], A[8], A[9] := 2, 4, 6, 15, 3, 19, 17, 16, 18, 1;
BubbleSort(A);
print A[..];
}
/* Explanation:
invariant forall n, m :: 0 <= n <= i <m <N ==> A [n] <= A [m]
// A is ordered for each pair of elements such that
// the first element belongs to the left partition of i
// and the second element belongs to the right partition of i
invariant forall n :: 0 <= n <= j ==> A [n] <= A [j]
// There is a variable defined by the value that the array takes at position j
// Therefore, each value that the array takes for all elements from 0 to j
// They are less than or equal to the value of the variable
*/
| Dafny-programs_tmp_tmpnso9eu7u_Algorithms + sorting_bubble-sort.dfy | 74 |
method addArrays(a : array<int>, b : array<int>) returns (c : array<int>)
requires a.Length == b.Length
ensures b.Length == c.Length
ensures forall i:int :: 0 <= i <c.Length ==> c[i] == a[i] + b[i]
{
c := new int[a.Length];
var j := 0;
while (j < a.Length)
{
c[j] := a[j] + b[j];
j := j + 1;
}
}
| method addArrays(a : array<int>, b : array<int>) returns (c : array<int>)
requires a.Length == b.Length
ensures b.Length == c.Length
ensures forall i:int :: 0 <= i <c.Length ==> c[i] == a[i] + b[i]
{
c := new int[a.Length];
var j := 0;
while (j < a.Length)
invariant 0 <= j <= c.Length
invariant forall i :: (0 <= i < j) ==> c[i] == a[i] + b[i];
{
c[j] := a[j] + b[j];
j := j + 1;
}
}
| DafnyExercises_tmp_tmpd6qyevja_Part1_Q1.dfy | 75 |
/**
Inverts an array of ints.
*/
method InvertArray(a: array<int>)
modifies a
ensures forall i | 0 <= i < a.Length :: a[i] == old(a[a.Length-1-i])
{
var index := 0;
while index < a.Length / 2
// the elements i before position index are already switched with the old value of position a.Length - 1 - i
// the elements of form a.Length - 1 - i after position a.Length - 1 - index are already switched with the old value of position i
// the elements between index and a.Length - index are unchanged : the middle of the array
{
a[index], a[a.Length - 1 - index] := a[a.Length - 1 - index], a[index];
index := index + 1;
}
}
| /**
Inverts an array of ints.
*/
method InvertArray(a: array<int>)
modifies a
ensures forall i | 0 <= i < a.Length :: a[i] == old(a[a.Length-1-i])
{
var index := 0;
while index < a.Length / 2
invariant 0 <= index <= a.Length / 2
// the elements i before position index are already switched with the old value of position a.Length - 1 - i
invariant forall i | 0 <= i < index :: a[i] == old(a[a.Length - 1 - i])
// the elements of form a.Length - 1 - i after position a.Length - 1 - index are already switched with the old value of position i
invariant forall i | 0 <= i < index :: a[a.Length - 1 - i] == old(a[i])
// the elements between index and a.Length - index are unchanged : the middle of the array
invariant forall i | index <= i < a.Length - index :: a[i] == old(a[i])
{
a[index], a[a.Length - 1 - index] := a[a.Length - 1 - index], a[index];
index := index + 1;
}
}
| DafnyPrograms_tmp_tmp74_f9k_c_invertarray.dfy | 76 |
End of preview. Expand in Data Studio
README.md exists but content is empty.
- Downloads last month
- 27