| /*@ Import Lean | |
| import Data_structures.priority_queue.lean.spec_lib | |
| open scoped SimpleC | |
| */ | |
| /*@ Extern Coq (multiset :: * => *) */ | |
| /*@ Extern Coq | |
| (heap_capacity : Z) | |
| (mlist : {A} -> multiset A -> list A) | |
| (list_to_multiset : {A} -> list A -> multiset A) | |
| (multiset_size : {A} -> multiset A -> Z) | |
| (multiset_equiv : {A} -> multiset A -> multiset A -> Prop) | |
| (multiset_insert : {A} -> multiset A -> A -> multiset A) | |
| (multiset_remove : | |
| {A} -> multiset A -> A -> multiset A) | |
| (multiset_max : multiset Z -> Z) | |
| (multiset_maximum : multiset Z -> Z -> Prop) | |
| (store_heap : Z -> multiset Z -> Z -> Assertion) | |
| (heap_retired_cell : Z -> Z -> Z -> Assertion) | |
| (heap_representation : | |
| multiset Z -> list Z -> Z -> Prop) | |
| (PrefixMaximum : list Z -> Z -> Z -> Prop) | |
| (PushSource : list Z -> multiset Z -> Z -> Z -> Prop) | |
| (PushLoopState : list Z -> list Z -> Z -> Z -> Z -> Prop) | |
| (PushResult : multiset Z -> list Z -> Z -> Z -> Prop) | |
| (BuildPrefixState : multiset Z -> list Z -> Z -> Prop) | |
| (heap_parent : Z -> Z) | |
| (PopLoopState : list Z -> list Z -> Z -> Z -> Prop) | |
| (PopSelectedChild : list Z -> Z -> Z -> Z -> Prop) | |
| (PopReadyState : list Z -> list Z -> Z -> Z -> Prop) | |
| (PopResult : | |
| multiset Z -> list Z -> list Z -> Z -> Z -> Prop) | |
| (HeapSortState : | |
| list Z -> multiset Z -> list Z -> Prop) | |
| (Permutation : list Z -> list Z -> Prop) | |
| (increasing : list Z -> Prop) | |
| */ | |
| void push(int *heap, int n, int x) | |
| /*@ With (S_before : multiset Z) | |
| Require | |
| n < heap_capacity && | |
| store_heap(heap, S_before, n) * | |
| IntArray::undef_seg(heap, n, n + 1) | |
| Ensure | |
| store_heap( | |
| heap, multiset_insert(S_before, x), n + 1 | |
| ) | |
| */ | |
| { | |
| /*@ Assert | |
| exists base, | |
| heap == heap@pre && n == n@pre && x == x@pre && | |
| 0 <= n@pre && n@pre < heap_capacity && | |
| heap_representation(S_before, base, n@pre) && | |
| IntArray::full(heap, n@pre, base) * | |
| IntArray::undef_seg(heap, n@pre, n@pre + 1) | |
| */ | |
| heap[n] = x; | |
| /*@ Assert | |
| exists written, | |
| heap == heap@pre && n == n@pre && x == x@pre && | |
| 0 <= n@pre && n@pre < heap_capacity && | |
| PushSource(written, S_before, n@pre, x@pre) && | |
| PushLoopState(written, written, n@pre, n@pre, x@pre) && | |
| IntArray::full(heap, n@pre + 1, written) | |
| */ | |
| int child = n; | |
| /*@ Inv Assert | |
| exists written current, | |
| heap == heap@pre && n == n@pre && x == x@pre && | |
| 0 <= n@pre && n@pre < heap_capacity && | |
| 0 <= child && child <= n@pre && | |
| PushSource(written, S_before, n@pre, x@pre) && | |
| PushLoopState(written, current, n@pre, child, x@pre) && | |
| IntArray::full(heap, n@pre + 1, current) | |
| */ | |
| while (child > 0) { | |
| int parent = (child - 1) / 2; | |
| /*@ Assert | |
| exists written current, | |
| heap == heap@pre && n == n@pre && x == x@pre && | |
| 0 <= n@pre && n@pre < heap_capacity && | |
| 0 < child && child <= n@pre && | |
| 0 <= parent && parent < child && parent <= n@pre && | |
| parent == heap_parent(child) && | |
| PushSource(written, S_before, n@pre, x@pre) && | |
| PushLoopState(written, current, n@pre, child, x@pre) && | |
| IntArray::full(heap, n@pre + 1, current) | |
| */ | |
| if (heap[parent] >= heap[child]) { | |
| /*@ Assert | |
| exists written current, | |
| heap == heap@pre && n == n@pre && x == x@pre && | |
| 0 <= n@pre && n@pre < heap_capacity && | |
| 0 < child && child <= n@pre && | |
| 0 <= parent && parent < child && parent <= n@pre && | |
| parent == heap_parent(child) && | |
| current[parent] >= current[child] && | |
| PushSource(written, S_before, n@pre, x@pre) && | |
| PushResult(S_before, current, n@pre, x@pre) && | |
| IntArray::full(heap, n@pre + 1, current) | |
| */ | |
| break; | |
| } | |
| int tmp = heap[parent]; | |
| heap[parent] = heap[child]; | |
| heap[child] = tmp; | |
| /*@ Assert | |
| exists written current, | |
| heap == heap@pre && n == n@pre && x == x@pre && | |
| 0 <= n@pre && n@pre < heap_capacity && | |
| 0 < child && child <= n@pre && | |
| 0 <= parent && parent < child && parent <= n@pre && | |
| parent == heap_parent(child) && | |
| tmp == current[child] && | |
| PushSource(written, S_before, n@pre, x@pre) && | |
| PushLoopState(written, current, n@pre, parent, x@pre) && | |
| IntArray::full(heap, n@pre + 1, current) | |
| */ | |
| child = parent; | |
| } | |
| /*@ Assert | |
| exists written result, | |
| heap == heap@pre && n == n@pre && x == x@pre && | |
| 0 <= n@pre && n@pre < heap_capacity && | |
| 0 <= child && child <= n@pre && | |
| PushSource(written, S_before, n@pre, x@pre) && | |
| PushResult(S_before, result, n@pre, x@pre) && | |
| IntArray::full(heap, n@pre + 1, result) | |
| */ | |
| /*@ Assert | |
| heap == heap@pre && n == n@pre && x == x@pre && | |
| 0 <= child && child <= n@pre && | |
| store_heap( | |
| heap, multiset_insert(S_before, x@pre), n@pre + 1 | |
| ) | |
| */ | |
| } | |
| void build(int *heap, int n) | |
| /*@ With (input : list Z) | |
| Require | |
| 0 <= n && | |
| n <= heap_capacity && | |
| Zlength(input) == n && | |
| IntArray::full(heap, n, input) | |
| Ensure | |
| store_heap(heap, list_to_multiset(input), n) | |
| */ | |
| { | |
| /*@ Inv Assert | |
| (heap == heap@pre && n == n@pre && | |
| n@pre == 0 && i == 1 && | |
| Zlength(input) == n@pre && | |
| IntArray::full(heap, n@pre, input)) | |
| || | |
| (exists S_prefix, | |
| heap == heap@pre && n == n@pre && | |
| 1 <= n@pre && n@pre <= heap_capacity && | |
| 1 <= i && i <= n@pre && | |
| Zlength(input) == n@pre && | |
| BuildPrefixState(S_prefix, input, i) && | |
| store_heap(heap, S_prefix, i) * | |
| IntArray::seg(heap, i, n@pre, sublist(i, n@pre, input))) | |
| */ | |
| for (int i = 1; i < n; ++i) { | |
| int x = heap[i]; | |
| /*@ Assert | |
| exists S_prefix, | |
| heap == heap@pre && n == n@pre && | |
| 1 <= n@pre && n@pre <= heap_capacity && | |
| 1 <= i && i < n@pre && | |
| x == input[i] && | |
| Zlength(input) == n@pre && | |
| BuildPrefixState(S_prefix, input, i) && | |
| store_heap(heap, S_prefix, i) * | |
| IntArray::undef_seg(heap, i, i + 1) * | |
| IntArray::seg(heap, i + 1, n@pre, | |
| sublist(i + 1, n@pre, input)) | |
| */ | |
| push(heap, i, x); | |
| /*@ Assert | |
| exists S_prefix, | |
| heap == heap@pre && n == n@pre && | |
| 1 <= n@pre && n@pre <= heap_capacity && | |
| 1 <= i && i < n@pre && | |
| x == input[i] && | |
| Zlength(input) == n@pre && | |
| BuildPrefixState(S_prefix, input, i) && | |
| store_heap( | |
| heap, multiset_insert(S_prefix, x), i + 1 | |
| ) * | |
| IntArray::seg(heap, i + 1, n@pre, | |
| sublist(i + 1, n@pre, input)) | |
| */ | |
| /*@ Assert | |
| exists S_prefix, | |
| heap == heap@pre && n == n@pre && | |
| 1 <= n@pre && n@pre <= heap_capacity && | |
| 1 <= i && i < n@pre && | |
| x == input[i] && | |
| Zlength(input) == n@pre && | |
| BuildPrefixState( | |
| multiset_insert(S_prefix, x), input, i + 1 | |
| ) && | |
| store_heap( | |
| heap, multiset_insert(S_prefix, x), i + 1 | |
| ) * | |
| IntArray::seg(heap, i + 1, n@pre, | |
| sublist(i + 1, n@pre, input)) | |
| */ | |
| } | |
| /*@ Assert | |
| heap == heap@pre && n == n@pre && | |
| store_heap(heap, list_to_multiset(input), n@pre) | |
| */ | |
| } | |
| int pop(int *heap, int n) | |
| /*@ With (S_before : multiset Z) | |
| Require | |
| 1 <= n && | |
| store_heap(heap, S_before, n) | |
| Ensure | |
| __return == multiset_max(S_before) && | |
| multiset_maximum(S_before, __return) && | |
| store_heap( | |
| heap, | |
| multiset_remove(S_before, multiset_max(S_before)), | |
| n - 1 | |
| ) * | |
| IntArray::undef_seg(heap, n - 1, n) | |
| */ | |
| { | |
| /*@ Assert | |
| exists before, | |
| heap == heap@pre && n == n@pre && | |
| 1 <= n@pre && n@pre <= heap_capacity && | |
| heap_representation(S_before, before, n@pre) && | |
| PrefixMaximum(before, n@pre, before[0]) && | |
| before[0] == multiset_max(S_before) && | |
| multiset_maximum(S_before, before[0]) && | |
| IntArray::full(heap, n@pre, before) | |
| */ | |
| int ret = heap[0]; | |
| /*@ Assert | |
| exists before, | |
| heap == heap@pre && n == n@pre && | |
| 1 <= n@pre && n@pre <= heap_capacity && | |
| ret == before[0] && | |
| ret == multiset_max(S_before) && | |
| heap_representation(S_before, before, n@pre) && | |
| PrefixMaximum(before, n@pre, ret) && | |
| multiset_maximum(S_before, ret) && | |
| IntArray::full(heap, n@pre, before) | |
| */ | |
| if (n == 1) { | |
| /*@ Assert | |
| heap == heap@pre && n == n@pre && | |
| n@pre == 1 && | |
| ret == multiset_max(S_before) && | |
| multiset_maximum(S_before, ret) && | |
| store_heap( | |
| heap, | |
| multiset_remove(S_before, multiset_max(S_before)), | |
| 0 | |
| ) * | |
| IntArray::undef_seg(heap, 0, 1) | |
| */ | |
| return ret; | |
| } | |
| heap[0] = heap[n - 1]; | |
| /*@ Assert | |
| exists before current, | |
| heap == heap@pre && n == n@pre && | |
| 1 < n@pre && n@pre <= heap_capacity && | |
| ret == before[0] && | |
| ret == multiset_max(S_before) && | |
| heap_representation(S_before, before, n@pre) && | |
| PrefixMaximum(before, n@pre, ret) && | |
| multiset_maximum(S_before, ret) && | |
| PopLoopState(before, current, n@pre, 0) && | |
| IntArray::full(heap, n@pre, current) | |
| */ | |
| int idx = 0; | |
| /*@ Inv Assert | |
| exists before current, | |
| heap == heap@pre && n == n@pre && | |
| 1 < n@pre && n@pre <= heap_capacity && | |
| ret == before[0] && | |
| ret == multiset_max(S_before) && | |
| heap_representation(S_before, before, n@pre) && | |
| PrefixMaximum(before, n@pre, ret) && | |
| multiset_maximum(S_before, ret) && | |
| 0 <= idx && idx < n@pre - 1 && | |
| 0 <= idx * 2 + 1 && idx * 2 + 1 <= INT_MAX && | |
| PopLoopState(before, current, n@pre, idx) && | |
| IntArray::full(heap, n@pre, current) | |
| */ | |
| while (idx * 2 + 1 < n - 1) { | |
| int left = idx * 2 + 1; | |
| int right = left + 1; | |
| int largest = left; | |
| /*@ Assert | |
| exists before current, | |
| heap == heap@pre && n == n@pre && | |
| 1 < n@pre && n@pre <= heap_capacity && | |
| ret == before[0] && | |
| ret == multiset_max(S_before) && | |
| heap_representation(S_before, before, n@pre) && | |
| PrefixMaximum(before, n@pre, ret) && | |
| multiset_maximum(S_before, ret) && | |
| 0 <= idx && idx < n@pre - 1 && | |
| left == idx * 2 + 1 && | |
| right == left + 1 && | |
| largest == left && | |
| 0 <= left && left < n@pre - 1 && | |
| 0 <= right && right <= n@pre - 1 && | |
| PopLoopState(before, current, n@pre, idx) && | |
| IntArray::full(heap, n@pre, current) | |
| */ | |
| if (right < n - 1 && heap[left] < heap[right]) { | |
| largest = right; | |
| } | |
| /*@ Assert | |
| exists before current, | |
| heap == heap@pre && n == n@pre && | |
| 1 < n@pre && n@pre <= heap_capacity && | |
| ret == before[0] && | |
| ret == multiset_max(S_before) && | |
| heap_representation(S_before, before, n@pre) && | |
| PrefixMaximum(before, n@pre, ret) && | |
| multiset_maximum(S_before, ret) && | |
| 0 <= idx && idx < n@pre - 1 && | |
| left == idx * 2 + 1 && | |
| right == left + 1 && | |
| 0 <= largest && largest < n@pre - 1 && | |
| PopSelectedChild(current, n@pre - 1, idx, largest) && | |
| PopLoopState(before, current, n@pre, idx) && | |
| IntArray::full(heap, n@pre, current) | |
| */ | |
| if (heap[idx] >= heap[largest]) { | |
| /*@ Assert | |
| exists before current, | |
| heap == heap@pre && n == n@pre && | |
| 1 < n@pre && n@pre <= heap_capacity && | |
| ret == before[0] && | |
| ret == multiset_max(S_before) && | |
| heap_representation(S_before, before, n@pre) && | |
| PrefixMaximum(before, n@pre, ret) && | |
| multiset_maximum(S_before, ret) && | |
| 0 <= idx && idx < n@pre - 1 && | |
| left == idx * 2 + 1 && | |
| right == left + 1 && | |
| 0 <= left && left < n@pre - 1 && | |
| 0 <= right && right <= n@pre - 1 && | |
| 0 <= largest && largest < n@pre - 1 && | |
| current[idx] >= current[largest] && | |
| PopSelectedChild(current, n@pre - 1, idx, largest) && | |
| PopReadyState(before, current, n@pre, ret) && | |
| IntArray::full(heap, n@pre, current) | |
| */ | |
| break; | |
| } | |
| int tmp = heap[idx]; | |
| heap[idx] = heap[largest]; | |
| heap[largest] = tmp; | |
| /*@ Assert | |
| exists before current, | |
| heap == heap@pre && n == n@pre && | |
| 1 < n@pre && n@pre <= heap_capacity && | |
| ret == before[0] && | |
| ret == multiset_max(S_before) && | |
| heap_representation(S_before, before, n@pre) && | |
| PrefixMaximum(before, n@pre, ret) && | |
| multiset_maximum(S_before, ret) && | |
| 0 <= idx && idx < n@pre - 1 && | |
| left == idx * 2 + 1 && | |
| right == left + 1 && | |
| 0 <= left && left < n@pre - 1 && | |
| 0 <= right && right <= n@pre - 1 && | |
| 0 <= largest && largest < n@pre - 1 && | |
| idx < largest && | |
| tmp == current[largest] && | |
| PopLoopState(before, current, n@pre, largest) && | |
| IntArray::full(heap, n@pre, current) | |
| */ | |
| idx = largest; | |
| } | |
| /*@ Assert | |
| exists before current, | |
| heap == heap@pre && n == n@pre && | |
| 1 < n@pre && n@pre <= heap_capacity && | |
| ret == before[0] && | |
| ret == multiset_max(S_before) && | |
| heap_representation(S_before, before, n@pre) && | |
| PrefixMaximum(before, n@pre, ret) && | |
| multiset_maximum(S_before, ret) && | |
| 0 <= idx && idx < n@pre - 1 && | |
| PopReadyState(before, current, n@pre, ret) && | |
| IntArray::full(heap, n@pre, current) | |
| */ | |
| /*@ Assert | |
| exists before result, | |
| heap == heap@pre && n == n@pre && | |
| 1 < n@pre && n@pre <= heap_capacity && | |
| 0 <= idx && idx < n@pre - 1 && | |
| ret == before[0] && | |
| ret == multiset_max(S_before) && | |
| heap_representation(S_before, before, n@pre) && | |
| PrefixMaximum(before, n@pre, ret) && | |
| multiset_maximum(S_before, ret) && | |
| PopResult(S_before, before, result, n@pre, ret) && | |
| IntArray::full(heap, n@pre, result) | |
| */ | |
| /*@ Assert | |
| heap == heap@pre && n == n@pre && | |
| 0 <= idx && idx < n@pre - 1 && | |
| ret == multiset_max(S_before) && | |
| multiset_maximum(S_before, ret) && | |
| store_heap( | |
| heap, | |
| multiset_remove(S_before, multiset_max(S_before)), | |
| n@pre - 1 | |
| ) * | |
| IntArray::undef_seg(heap, n@pre - 1, n@pre) | |
| */ | |
| return ret; | |
| } | |
| void heap_sort(int *heap, int n) | |
| /*@ With (input : list Z) | |
| Require | |
| 0 <= n && | |
| n <= heap_capacity && | |
| Zlength(input) == n && | |
| IntArray::full(heap, n, input) | |
| Ensure | |
| exists output, | |
| Zlength(output) == n && | |
| Permutation(input, output) && | |
| increasing(output) && | |
| IntArray::full(heap, n, output) | |
| */ | |
| { | |
| build(heap, n) /*@ where input = input */; | |
| /*@ Assert | |
| heap == heap@pre && n == n@pre && | |
| 0 <= n@pre && n@pre <= heap_capacity && | |
| Zlength(input) == n@pre && | |
| multiset_size(list_to_multiset(input)) == n@pre && | |
| HeapSortState( | |
| input, list_to_multiset(input), nil | |
| ) && | |
| store_heap( | |
| heap, list_to_multiset(input), n@pre | |
| ) * | |
| IntArray::seg(heap, n@pre, n@pre, nil) | |
| */ | |
| int i = n; | |
| /*@ Inv Assert | |
| exists active suffix, | |
| heap == heap@pre && n == n@pre && | |
| 0 <= n@pre && n@pre <= heap_capacity && | |
| Zlength(input) == n@pre && | |
| 0 <= i && i <= n@pre && | |
| multiset_size(active) == i && | |
| Zlength(suffix) == n@pre - i && | |
| HeapSortState(input, active, suffix) && | |
| store_heap(heap, active, i) * | |
| IntArray::seg(heap, i, n@pre, suffix) | |
| */ | |
| while (i > 0) { | |
| /*@ Assert | |
| exists active suffix, | |
| heap == heap@pre && n == n@pre && | |
| 0 <= n@pre && n@pre <= heap_capacity && | |
| Zlength(input) == n@pre && | |
| 1 <= i && i <= n@pre && | |
| multiset_size(active) == i && | |
| Zlength(suffix) == n@pre - i && | |
| HeapSortState(input, active, suffix) && | |
| store_heap(heap, active, i) * | |
| IntArray::seg(heap, i, n@pre, suffix) | |
| */ | |
| int extracted = pop(heap, i); | |
| /*@ Assert | |
| exists active suffix, | |
| heap == heap@pre && n == n@pre && | |
| 0 <= n@pre && n@pre <= heap_capacity && | |
| Zlength(input) == n@pre && | |
| 1 <= i && i <= n@pre && | |
| extracted == multiset_max(active) && | |
| multiset_maximum(active, extracted) && | |
| multiset_size(active) == i && | |
| Zlength(suffix) == n@pre - i && | |
| HeapSortState(input, active, suffix) && | |
| store_heap( | |
| heap, | |
| multiset_remove(active, multiset_max(active)), | |
| i - 1 | |
| ) * | |
| IntArray::undef_seg(heap, i - 1, i) * | |
| IntArray::seg(heap, i, n@pre, suffix) | |
| */ | |
| heap[i - 1] = extracted; | |
| /*@ Assert | |
| exists active suffix, | |
| heap == heap@pre && n == n@pre && | |
| 0 <= n@pre && n@pre <= heap_capacity && | |
| Zlength(input) == n@pre && | |
| 1 <= i && i <= n@pre && | |
| extracted == multiset_max(active) && | |
| multiset_maximum(active, extracted) && | |
| multiset_size(active) == i && | |
| Zlength(suffix) == n@pre - i && | |
| HeapSortState(input, active, suffix) && | |
| store_heap( | |
| heap, | |
| multiset_remove(active, multiset_max(active)), | |
| i - 1 | |
| ) * | |
| heap_retired_cell(heap, i - 1, extracted) * | |
| IntArray::seg(heap, i, n@pre, suffix) | |
| */ | |
| --i; | |
| /*@ Assert | |
| exists active suffix, | |
| heap == heap@pre && n == n@pre && | |
| 0 <= n@pre && n@pre <= heap_capacity && | |
| Zlength(input) == n@pre && | |
| 0 <= i && i < n@pre && | |
| multiset_size( | |
| multiset_remove(active, multiset_max(active)) | |
| ) == i && | |
| Zlength(cons(extracted, suffix)) == n@pre - i && | |
| HeapSortState( | |
| input, | |
| multiset_remove(active, multiset_max(active)), | |
| cons(extracted, suffix) | |
| ) && | |
| store_heap( | |
| heap, | |
| multiset_remove(active, multiset_max(active)), | |
| i | |
| ) * | |
| IntArray::seg( | |
| heap, i, n@pre, cons(extracted, suffix) | |
| ) | |
| */ | |
| } | |
| /*@ Assert | |
| exists output, | |
| heap == heap@pre && n == n@pre && | |
| 0 <= n@pre && n@pre <= heap_capacity && | |
| i == 0 && | |
| Zlength(input) == n@pre && | |
| Zlength(output) == n@pre && | |
| Permutation(input, output) && | |
| increasing(output) && | |
| IntArray::full(heap, n@pre, output) | |
| */ | |
| } | |