use vstd::prelude::*;
fn main() {}
verus!{


spec fn f1_seq_to_set_rec<A>(seq: Seq<A>) -> Set<A>
    decreases seq.len()
{
    if seq.len() == 0 {
        Set::empty()
    } else {
        f1_seq_to_set_rec(seq.drop_last()).insert(seq.last())
    }
}

/// helper function showing that the resulting set contains all elements of the sequence
proof fn f1_seq_to_set_rec_contains<A>(seq: Seq<A>)
    ensures forall |a| #[trigger] seq.contains(a) <==> f1_seq_to_set_rec(seq).contains(a)
    decreases seq.len()
{
    if seq.len() > 0 {
        assert(forall |a| #[trigger] seq.drop_last().contains(a) <==> f1_seq_to_set_rec(seq.drop_last()).contains(a)) by {
            f1_seq_to_set_rec_contains(seq.drop_last());
        }

        assert(seq =~= (seq.drop_last().push(seq.last())));
        assert forall |a| #[trigger] seq.contains(a) <==> f1_seq_to_set_rec(seq).contains(a) by {
            if !seq.drop_last().contains(a) {
                if a == seq.last() {
                    assert(seq.contains(a));
                    assert(f1_seq_to_set_rec(seq).contains(a));
                } else {
                    assert(!f1_seq_to_set_rec(seq).contains(a));
                }
            }
        }
    }
}

/// helper function showing that the recursive definition matches the set comprehension one
proof fn f1_seq_to_set_equal_rec<A>(seq: Seq<A>)
    ensures seq.to_set() == f1_seq_to_set_rec(seq)
{
    assert(forall |n| #[trigger] seq.contains(n) <==> f1_seq_to_set_rec(seq).contains(n)) by {
        f1_seq_to_set_rec_contains(seq);
    }
    assert(forall |n| #[trigger] seq.contains(n) <==> seq.to_set().contains(n));
    assert(seq.to_set() =~= f1_seq_to_set_rec(seq));
}

proof fn f1_lemma_seq_push_to_set_insert<T>(s: Seq<T>, val: T)
ensures
    s.push(val).to_set() === s.to_set().insert(val),
{
    f1_seq_to_set_equal_rec(s.push(val));
    assert(s =~= s.push(val).drop_last());
    f1_seq_to_set_equal_rec(s);
    assert(s.push(val).to_set() === f1_seq_to_set_rec(s.push(val)));
    assert(s.push(val).to_set() === f1_seq_to_set_rec(s.push(val).drop_last()).insert(val));
}

fn f1_remove_duplicates(nums: Vec<i32>) -> (res: Vec<i32>)
{
    let mut res = Vec::new();
    let mut i = 0;
    while i < nums.len()
    {
        let mut found = false;
        let mut j = 0;

        while j < res.len()
        invariant_except_break
            !found
        {
            if nums[i] == res[j] {
                found = true;
                break;
            }
            j += 1;
        }
        
        if !found {
            res.push(nums[i]);
        }
        i += 1;
    }
    
    res
}


spec fn step1(__hp0: Seq<i32>, outp: Seq<i32>) -> bool {
    (outp.no_duplicates())
    && (__hp0.to_set() =~= (outp.to_set()))
}

fn chain_driver(nums: Vec<i32>) -> (r_final: Vec<i32>)
    ensures
        step1(nums@, r_final@),
{
    let x1 = f1_remove_duplicates(nums);
    proof {
        assert(step1(nums@, x1@));
    }
    x1
}

} // verus!