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
    Dafny/copy.dfy(24,5): anon20_LoopHead
    (0,0): anon20_LoopBody
    Dafny/copy.dfy(24,5): anon21_Else
    (0,0): anon23_Then
    Dafny/copy.dfy(35,5): anon24_LoopHead
    (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
    Dafny/copy.dfy(24,5): anon20_LoopHead
    (0,0): anon20_LoopBody
    Dafny/copy.dfy(24,5): anon21_Else
    (0,0): anon23_Then
    Dafny/copy.dfy(35,5): anon24_LoopHead
    (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

Answers


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

Need Your Help

bootstrap jumbotron full width image

html asp.net twitter-bootstrap

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

angularjs angularjs-directive angularjs-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...