completed programs roughly from 70 to 80 #11

edwin1729 · 2024-09-17T04:56:43Z

No description provided.

…nto in-progress

also remove the palindrome helper lemmas, they were automatically deduced

…mallest even

parno

Thanks for making so much progress on so many tasks! This is great to see.

As a minor suggestion, inside the Verus code base, we typically topologically sort our files, so that the leaf functions are at the top, and the entrypoint is at the bottom. Doing that here might make things a bit easier to review in some cases (like for Task 70).

parno · 2024-09-17T18:58:17Z

tasks/human_eval_007.rs

@@ -9,7 +9,101 @@ use vstd::prelude::*;

 verus! {

-// TODO: Put your solution (the specification, implementation, and proof) to the task here
+fn filter_by_substring<'a>(strings: &Vec<&'a str>, substring: &str) -> (res: Vec<&'a str>)
+    ensures


This spec says that anything that we return contains the substring and was in the original strings list. To match the English description's intention, I think it might need to be strengthened to say that if there is a string in strings that contains the substring, then it will appear in res.

I wonder if this spec might be expressed using a filter, e.g., res@ == [email protected](|s| s.has_substring(substring), for a suitable definition of has_substring.

I've rewritten the the spec to capture the prompt

I think this version captures the property I mentioned above, but I think it might have lost the property your previous version included. In other words, I think your current spec would allow the function to return the entire input list.

Perhaps you could show that combining your two versions of the spec imply the filter-based spec above.

tasks/human_eval_012.rs

tasks/human_eval_014.rs

tasks/human_eval_068.rs

tasks/human_eval_074.rs

tasks/human_eval_076.rs

parno · 2024-09-17T20:28:27Z

tasks/human_eval_077.rs

+        x != i32::MIN,  // avoid overflow: -(i32::MIN) == (i32::MAX) + 1
+
+    ensures
+        ret <==> exists|i: int| 0 <= i && abs(x as int) == #[trigger] (i * i * i),


Is it possible to show that this is equivalent to this?

ret <==> exists|i: int| x == #[trigger] (i * i * i),

That's what I was initially expecting to see, given the English prompt.

parno · 2024-09-19T01:45:45Z

@parno is it okay if a program verifies with cvc5 and doesn't with z3?

At the moment, cvc5 support is still pretty experimental, so I think we should aim to get everything to verify with Z3.

WeetHet · 2024-09-19T05:15:27Z

@parno is it okay if a program verifies with cvc5 and doesn't with z3?

At the moment, cvc5 support is still pretty experimental, so I think we should aim to get everything to verify with Z3.

Could you help me with 034? I can't get it to work with z3

ahuoguo · 2024-09-19T05:55:49Z

@parno is it okay if a program verifies with cvc5 and doesn't with z3?

At the moment, cvc5 support is still pretty experimental, so I think we should aim to get everything to verify with Z3.

Could you help me with 034? I can't get it to work with z3

This should work.

fn unique_sorted(s: Vec<i32>) -> (result: Vec<i32>)
    requires
        forall|i: int, j: int| 0 <= i < j < s.len() ==> s[i] <= s[j],
    ensures
        forall|i: int, j: int| 0 <= i < j < result.len() ==> result[i] < result[j],
        forall|i: int| #![auto] 0 <= i < result.len() ==> s@.contains(result[i]),
        forall|i: int| #![trigger s[i]] 0 <= i < s.len() ==> result@.contains(s[i]),
{
    let mut result: Vec<i32> = vec![];
    for i in 0..s.len()
        invariant
            forall|i: int, j: int| 0 <= i < j < s.len() ==> s[i] <= s[j],
            forall|k: int, l: int| 0 <= k < l < result.len() ==> result[k] < result[l],
            forall|k: int|
                #![trigger result[k]]
                0 <= k < result.len() ==> (exists|m: int| 0 <= m < i && result[k] == s[m]),
            forall|m: int| #![trigger s[m]] 0 <= m < i ==> result@.contains(s[m]),
    {
        let ghost pre = result;
        if result.len() == 0 || result[result.len() - 1] != s[i] {
            assert(result.len() == 0 || result[result.len() - 1] < s[i as int]);
            result.push(s[i]);
            assert forall|m: int| #![trigger s[m]] 0 <= m < i implies result@.contains(s[m]) by {
                assert(pre@.contains(s@[m]));
                lemma_seq_contains_after_push(pre@, s@[i as int], s@[m]);
            };
        }
        assert(forall|m: int|
            #![trigger result@[m], pre@[m]]
            0 <= m < pre.len() ==> pre@.contains(result@[m]) ==> result@.contains(pre@[m])) by {
            assert(forall|m: int| 0 <= m < pre.len() ==> result@[m] == pre@[m]);
        }
        assert(result@.contains(s[i as int])) by {
            assert(result[result.len() - 1] == s[i as int]);
        }
    }
    result
}

Also include

use vstd::seq_lib::lemma_seq_contains_after_push;

in the front.

PS: I ran your 034 with CVC5 but it did not pass. Did you use verus -V cvc5 human_eval_034.rs ? Or am I missing a flag?

PS2: Another way to do 034 is probably creating a HashSet from Vec, but it probably involves extending vstd.

WeetHet · 2024-09-19T06:34:08Z

@parno is it okay if a program verifies with cvc5 and doesn't with z3?

At the moment, cvc5 support is still pretty experimental, so I think we should aim to get everything to verify with Z3.

Could you help me with 034? I can't get it to work with z3

This should work.

fn unique_sorted(s: Vec<i32>) -> (result: Vec<i32>)
    requires
        forall|i: int, j: int| 0 <= i < j < s.len() ==> s[i] <= s[j],
    ensures
        forall|i: int, j: int| 0 <= i < j < result.len() ==> result[i] < result[j],
        forall|i: int| #![auto] 0 <= i < result.len() ==> s@.contains(result[i]),
        forall|i: int| #![trigger s[i]] 0 <= i < s.len() ==> result@.contains(s[i]),
{
    let mut result: Vec<i32> = vec![];
    for i in 0..s.len()
        invariant
            forall|i: int, j: int| 0 <= i < j < s.len() ==> s[i] <= s[j],
            forall|k: int, l: int| 0 <= k < l < result.len() ==> result[k] < result[l],
            forall|k: int|
                #![trigger result[k]]
                0 <= k < result.len() ==> (exists|m: int| 0 <= m < i && result[k] == s[m]),
            forall|m: int| #![trigger s[m]] 0 <= m < i ==> result@.contains(s[m]),
    {
        let ghost pre = result;
        if result.len() == 0 || result[result.len() - 1] != s[i] {
            assert(result.len() == 0 || result[result.len() - 1] < s[i as int]);
            result.push(s[i]);
            assert forall|m: int| #![trigger s[m]] 0 <= m < i implies result@.contains(s[m]) by {
                assert(pre@.contains(s@[m]));
                lemma_seq_contains_after_push(pre@, s@[i as int], s@[m]);
            };
        }
        assert(forall|m: int|
            #![trigger result@[m], pre@[m]]
            0 <= m < pre.len() ==> pre@.contains(result@[m]) ==> result@.contains(pre@[m])) by {
            assert(forall|m: int| 0 <= m < pre.len() ==> result@[m] == pre@[m]);
        }
        assert(result@.contains(s[i as int])) by {
            assert(result[result.len() - 1] == s[i as int]);
        }
    }
    result
}

Also include

use vstd::seq_lib::lemma_seq_contains_after_push;

in the front.

PS: I ran your 034 with CVC5 but it did not pass. Did you use verus -V cvc5 human_eval_034.rs ? Or am I missing a flag?

PS2: Another way to do 034 is probably creating a HashSet from Vec, but it probably involves extending vstd.

Weird, maybe it's because I have cvc5 1.2.0 and not 1.1.2?

Co-authored-by: Bryan Parno <[email protected]>

ahuoguo · 2024-09-19T06:43:44Z

PS: I ran your 034 with CVC5 but it did not pass. Did you use verus -V cvc5 human_eval_034.rs ? Or am I missing a flag?

Weird, maybe it's because I have cvc5 1.2.0 and not 1.1.2?

Huh! It was indeed a version issue (it passed on my end after using cvc5 1.20 instead of 1.12). That's interesting.

parno

I added a few responses to the latest edits. It looks like you also added some new files? If so, I haven't looked at them yet; I wasn't sure if they were ready for review. It might be easier to do them in a separate PR (or at least do any new tasks on a separate PR).

parno · 2024-09-19T14:17:20Z

tasks/human_eval_007.rs

@@ -9,7 +9,101 @@ use vstd::prelude::*;

 verus! {

-// TODO: Put your solution (the specification, implementation, and proof) to the task here
+fn filter_by_substring<'a>(strings: &Vec<&'a str>, substring: &str) -> (res: Vec<&'a str>)
+    ensures


I think this version captures the property I mentioned above, but I think it might have lost the property your previous version included. In other words, I think your current spec would allow the function to return the entire input list.

Perhaps you could show that combining your two versions of the spec imply the filter-based spec above.

tasks/human_eval_012.rs

tasks/human_eval_074.rs

tasks/human_eval_076.rs

edwin1729 · 2024-10-03T17:28:38Z

Hi sorry for the prolonged silence. I intend to complete these programs slowly over weekends now that term has started for me. Thanks as always for the feedback

parno · 2024-10-04T01:42:01Z

No problem -- we totally understand you have other demands on your time!

edwin1729 and others added 23 commits September 5, 2024 11:38

wrote 7 programs

8d40628

run verusfmt

226e36e

fix error in spec of correct bracketing - 56 and 61

ad1a362

complete 62 63 and 64

b0a0ce6

initial commit in branch in-progress

63ac4f1

complete is_cube excpet for lemma that cubes are increasing

ee82f5e

complete is_cube excpet for lemma that cubes are increasing

bbe5c9e

Merge branch 'main' of github.com:secure-foundations/human-eval-verus

ef6c6d6

add iterative fibonacci (55) and minor spec change to 56 and 61

103a490

complete proof that cubes are increasing

e667d0b

complete 75, product of 3 primes

9cf8c07

Merge branch 'in-progress' of github.com:edwin1729/human-eval-verus i…

6427427

…nto in-progress

complete will_it_fly by completing proof of increasing sum

2d543ad

also remove the palindrome helper lemmas, they were automatically deduced

adding a simple loop invariant to strange sort completes it

204444b

use the quantifiers instead of functional programs as spec in pluck s…

828facb

…mallest even

complete 74 (total match) and overflow checks in 76 (is_simple_power)

5a17b65

undo programs 54 and 66

78e532d

Merge remote-tracking branch 'upstream/main' into in-progress

13f28ef

Merge pull request #1 from edwin1729/in-progress

e3e52e9

Merge branch 'secure-foundations:main' into main

5ddff8b

fix lint

d4f9075

complete filter_by_substring (007)

5eea4f9

task 12

9f555fe

WeetHet force-pushed the main branch from f1ad7a1 to 9f555fe Compare September 17, 2024 10:37

task 14

0045f49

WeetHet force-pushed the main branch from a66b861 to 0045f49 Compare September 17, 2024 10:39

remove loop_isolation(false) from 14

3706820

parno reviewed Sep 17, 2024

View reviewed changes

edwin1729 and others added 2 commits September 18, 2024 10:55

sort functions in topological order

424c6c2

Parenthesize forall and exists

bb0d95d

Complete 034 (cvc5 only)

eec17a9

WeetHet force-pushed the main branch from 2b9b9ab to eec17a9 Compare September 18, 2024 12:11

edwin1729 added 2 commits September 18, 2024 17:45

fix lint

d96a82b

complete 134: check if last char is a letter

5d57ec3

edwin1729 force-pushed the main branch from 1fb6c90 to 5d57ec3 Compare September 18, 2024 12:21

update spec for 007 and 074

9ba1d3f

complete task 073

ce76290

edwin1729 force-pushed the main branch from fdc8d22 to ce76290 Compare September 19, 2024 06:16

Make 034 verify without cvc5

61d0f6a

Co-authored-by: Bryan Parno <[email protected]>

WeetHet force-pushed the main branch from 016cbac to 61d0f6a Compare September 19, 2024 06:39

WeetHet and others added 8 commits September 19, 2024 09:44

Complete 035

1bb4040

Complete 043

696cdd6

Relax restrictions a bit

f2012ef

Complete 049

28a3e27

Complete 050

29966f7

complete 136 reformat 068

88df3fe

Complete 054

b6d0d22

Complete 080

6751f5d

parno reviewed Sep 19, 2024

View reviewed changes

edwin1729 and others added 4 commits December 23, 2024 09:42

strengthen postcondition on 007 (substring filtering)

f7a7d83

remove commented proof code from 007

f9c2fad

Merge branch 'secure-foundations:main' into main

1b03c0f

Merge branch 'main' of github.com:edwin1729/human-eval-verus

25afa53

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

completed programs roughly from 70 to 80 #11

completed programs roughly from 70 to 80 #11

edwin1729 commented Sep 17, 2024

parno left a comment

parno Sep 17, 2024

edwin1729 Sep 19, 2024

parno Sep 19, 2024

parno Sep 17, 2024

parno commented Sep 19, 2024

WeetHet commented Sep 19, 2024

ahuoguo commented Sep 19, 2024 •

edited

Loading

WeetHet commented Sep 19, 2024

ahuoguo commented Sep 19, 2024 •

edited

Loading

parno left a comment

parno Sep 19, 2024

edwin1729 commented Oct 3, 2024

parno commented Oct 4, 2024

completed programs roughly from 70 to 80 #11

Are you sure you want to change the base?

completed programs roughly from 70 to 80 #11

Conversation

edwin1729 commented Sep 17, 2024

parno left a comment

Choose a reason for hiding this comment

parno Sep 17, 2024

Choose a reason for hiding this comment

edwin1729 Sep 19, 2024

Choose a reason for hiding this comment

parno Sep 19, 2024

Choose a reason for hiding this comment

parno Sep 17, 2024

Choose a reason for hiding this comment

parno commented Sep 19, 2024

WeetHet commented Sep 19, 2024

ahuoguo commented Sep 19, 2024 • edited Loading

WeetHet commented Sep 19, 2024

ahuoguo commented Sep 19, 2024 • edited Loading

parno left a comment

Choose a reason for hiding this comment

parno Sep 19, 2024

Choose a reason for hiding this comment

edwin1729 commented Oct 3, 2024

parno commented Oct 4, 2024

ahuoguo commented Sep 19, 2024 •

edited

Loading

ahuoguo commented Sep 19, 2024 •

edited

Loading