anchor.diff:  
   gen_vclock() ->
       frequency([
  -               {1, vclock:fresh()},
  -               {3, ?LAZY(?LET({Actor, Vc},
  -                              {gen_actor_id(), gen_vclock()},
  -                              vclock:increment(Actor, Vc)))}
  +               {1, {new_model(), vclock:fresh()}},
  +               {3, ?LAZY(gen_incr_vclock())}
                 ]).
   
  -model_merge(M, V) ->
  -    orddict:map(fun(A,C) ->
  -                        erlang:max(C,vclock:get_counter(A, V)) 
  -                end, M).
  +gen_incr_vclock() ->
  +    ?LET({Actor, {M,Vc}},
  +         {gen_actor_id(), gen_vclock()},
  +         {orddict:update_counter(Actor, 1, M), vclock:increment(Actor, Vc)}).
  +
  +merge({_,O}, V) ->
  +    vclock:merge([O,V]).
  +
  +model_merge(M,OM) ->
  +    orddict:merge(fun(_K,A,B) -> erlang:max(A,B) end, M, OM).
  +
  +new_model() ->
  +    orddict:from_list([{ID, 0} || ID <- ?ACTOR_IDS]).
   -endif.
  
positive.code:     oneof([
             {call, vclock, increment, [gen_actor_id(), S#state.vclock]},
             {call, vclock, get_counter, [gen_actor_id(), S#state.vclock]},
             {call, vclock, merge, [[gen_vclock(), S#state.vclock]]}
            ]).
  
  %% Next state transformation, S is the current state
  
negative.code: postcondition(#state{model=M}, {call,vclock,get_counter,[ActorId, _]}, Res) ->
      %% The counter for a given actor is the same as the model
      Res == orddict:fetch(ActorId, M);
  postcondition(#state{model=M}, {call,_,merge,[{OM,Other},VClock]}, Res) ->
      Merged = model_merge(M, OM),
      %% The merged state has all the same actor counts
      lists:all(fun(A) -> orddict:fetch(A,Merged) == vclock:get_counter(A,Res) end, 
                ?ACTOR_IDS) andalso
          %% The merged vector clock descends from both inputs
          vclock:descends(Res, Other) andalso vclock:descends(Res, VClock);
  postcondition(_S, _C, _Res) ->
      true.
  