在BubbleSort证明中我会错过什么不变量？

Question

我想我可能需要额外的不变量来说服Dafny代码有效。我尝试了一些但未能通过。

method BubbleSort(arr: array<int>)
    ensures forall k, k' :: 0 <= k < k' < arr.Length ==> arr[k] <= arr[k']
    modifies arr
{
    var i := arr.Length;
    while i > 0
        invariant 0 <= i <= arr.Length
        // Violating the invariant next line
        invariant forall k, k' :: i <= k < k' < arr.Length ==> arr[k] <= arr[k']
        decreases i
    {
        var j := 0;
        while j < i - 1
            invariant 0 <= j < i
            invariant forall k :: 0 <= k < j ==> arr[j] >= arr[k]
            decreases i - j
        {
            if arr[j] > arr[j+1] {
                arr[j], arr[j+1] := arr[j+1], arr[j];
            }
            j := j + 1;
        }
        i := i - 1;
    }
}

Answer 1

当i减小时，必须保持不变的排序（a，i，a。长度-1）。不变的分配（a，i）保证了这一点，因为它暗示了[i-1] <= a [i]。它比这更强大的原因是否则无法证明其不变性。

注意：分区（a，i）表示对于所有k <= i且i <1，a [k] <= a [l]。

Answer 2

我在这些笔记中找到了这个dafny验证冒泡排序的例子。

https://www.cs.cmu.edu/~mfredrik/15414/lectures/17-notes.pdf

predicate sorted ( a : array <int > , l : int , u : int)
reads a
{
 forall i , j :: 0 <= l <= i <= j <= u < a . Length ==> a [ i ] <= a [ j ]
}

predicate partitioned ( a : array <int > , i : int)
reads a
{
forall k , k' :: 0 <= k <= i < k' < a . Length ==> a [ k ] <= a [k']
}

method BubbleSort(a: array<int>) returns (b: array<int>)
requires a.Length!=0
modifies a
ensures sorted(a,0,a.Length-1)
{
  var i:=0;
  var j:=0;
  var temp:=0;
  var n:=a.Length;
  i:=n-1;
  b:=a;
  while i>0
  invariant i<0 ==> a.Length==0
  invariant -1<=i<n
  invariant sorted (a , i , a . Length -1)
  invariant partitioned(a,i)
  { 
   j:=0; 
   while j<i
   invariant 0<=j<=i
   invariant 0<=i<n
   invariant sorted(a , i , a . Length -1)
   invariant forall k :: 0 <= k <j ==> a[j] >= a[k]
   invariant partitioned(a,i)
   { if a[j]>a[j+1]
     {
       temp:=a[j];
       a[j]:=a[j+1];
       a[j+1]:=temp; 
     }
     j:=j+1; 
   }
   i:=i-1;
  }
  b:=a;

}