# Dafny: copy array region method validation

I am working on a language comparison of several languages created with verification in mind (Whiley, Dafny and Frama-C etc.) I was given this example of a function which copied a region of one array to another array with different placement within the destination array. The specification I came up with looks like this in Dafny:

```method copy( src: array<int>, sStart: nat, dest: array<int>, dStart: nat, len: nat)
returns (r: array<int>)
// both arrays cannot be null
requires dest != null && src != null
// Source array must contain enough elements to be copied
requires src.Length >= sStart + len
// Destination array must have enough space for copied elements
requires dest.Length >= dStart + len
// Result is same size as dest
ensures r != null
ensures r.Length == dest.Length
// All elements before copied region are same
ensures r[..dStart] == dest[..dStart]
// All elements above copied region are same
ensures r[dStart + len..] == dest[dStart + len..]
// All elements in copied region match src
ensures forall k: nat :: k < len ==> r[dStart + k] == src[sStart + k]

{
if len == 0 { return dest; }
assert len > 0;
var i: nat := 0;
r := new int[dest.Length];
while (i < r.Length)
invariant i <= r.Length
decreases r.Length - i
invariant r.Length == dest.Length
invariant forall k: nat :: k < i ==> r[k] == dest[k]
{
r[i] := dest[i];
i := i + 1;
}
assume r[..] == dest[..];
i := 0;
while (i < len)
invariant i <= len
decreases len - i
invariant r.Length == dest.Length
invariant r.Length >= dStart + i
invariant src.Length >= sStart + i
invariant r[..dStart] == dest[..dStart]
invariant r[(dStart + len)..] == dest[(dStart + len)..]
invariant forall k: nat :: k < i ==> r[dStart + k] == src[sStart + k]
{
r[dStart + i] := src[sStart + i];
i := i + 1;
}
}
```

In the second while loop above there may be some unneeded invariants as I have tried to cover everything I can think of. but, yeah, this doesn't verify and I am perplexed as to why...

```Dafny/copy.dfy(35,4): Error BP5003: A postcondition might not hold on this return path.
Dafny/copy.dfy(17,11): Related location: This is the postcondition that might not hold.
Execution trace:
(0,0): anon0
(0,0): anon19_Else
(0,0): anon20_LoopBody
Dafny/copy.dfy(24,5): anon21_Else
(0,0): anon23_Then
(0,0): anon24_LoopBody
Dafny/copy.dfy(35,5): anon25_Else
(0,0): anon27_Then
Dafny/copy.dfy(43,16): Error BP5005: This loop invariant might not be maintained by the loop.
Execution trace:
(0,0): anon0
(0,0): anon19_Else
(0,0): anon20_LoopBody
Dafny/copy.dfy(24,5): anon21_Else
(0,0): anon23_Then
(0,0): anon24_LoopBody
Dafny/copy.dfy(35,5): anon25_Else
Dafny/copy.dfy(35,5): anon27_Else

Dafny program verifier finished with 1 verified, 2 errors
```

You can get it to verify by adding one more invariant

```invariant r[dStart .. dStart + i] == src[sStart .. sStart + i]
```

As in:

```while (i < len)
invariant i <= len
decreases len - i
invariant r.Length == dest.Length
invariant r.Length >= dStart + i
invariant src.Length >= sStart + i
invariant r[..dStart] == dest[..dStart]
invariant r[(dStart + len)..] == dest[(dStart + len)..]
invariant r[dStart .. dStart + i] == src[sStart .. sStart + i]
invariant forall k: nat :: k < i ==> r[dStart + k] == src[sStart + k]
```

By the way, I think you can remove many of the invariants if you want to

```method copy( src: array<int>, sStart: nat, dest: array<int>, dStart: nat, len: nat)
returns (r: array<int>)
// both arrays cannot be null
requires dest != null && src != null
// Source array must contain enough elements to be copied
requires src.Length >= sStart + len
// Destination array must have enough space for copied elements
requires dest.Length >= dStart + len
// Result is same size as dest
ensures r != null
ensures r.Length == dest.Length
// All elements before copied region are same
ensures r[..dStart] == dest[..dStart]
// All elements above copied region are same
ensures r[dStart + len..] == dest[dStart + len..]
// All elements in copied region match src
ensures forall k: nat :: k < len ==> r[dStart + k] == src[sStart + k]

{
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;
}

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]
{
r[dStart + i] := src[sStart + i];
i := i + 1;
}
}
```

### bootstrap jumbotron full width image

I have a cover on all pages.. I am using jumbotron to have a full width image. but it leaves a space on right and left side. I added margin-left so the blank space on left was gone but the right on...

### AngularJS - Manual compile vs natural compile

It seems to be pretty generally accepted you shouldn't need to manually compile elements (via the \$compile service) very often. Because of some dynamically driven html we have a directive that is d...