anchor.diff:          lists:usort(riak_dt_gset:value(Previous)) =/=
           lists:usort(riak_dt_gset:value(Current));
   
  -is_lattice_strict_inflation(riak_dt_gcounter, [], []) ->
  -    false;
  +is_lattice_strict_inflation(riak_dt_orset, [], Current)
  +  when Current =/= []->
  +    true;
  +is_lattice_strict_inflation(riak_dt_orset, Previous, Current) ->
  +    is_lattice_inflation(riak_dt_orset, Previous, Current) andalso
  +    %% We already know that `Previous' is fully covered in `Current', so
  +    %% we just need to look for a change -- removal (false -> true), or
  +    %% addition of a new element.
  +        lists:foldl(fun({Element, Ids}, Acc) ->
  +                            {_, Ids1} = lists:keyfind(Element, 1, Current),
  +                            Acc orelse Ids =/= Ids1
  +                    end, false, Previous);
  +
   is_lattice_strict_inflation(riak_dt_gcounter, Previous, Current) ->
  -    PreviousList = lists:sort(orddict:to_list(Previous)),
  -    CurrentList = lists:sort(orddict:to_list(Current)),
  -    is_lattice_inflation(riak_dt_gcounter, Previous, Current) andalso
  -        lists:foldl(fun({Actor, Count}, Acc) ->
  -                case lists:keyfind(Actor, 1, CurrentList) of
  -                    false ->
  -                        Acc andalso false;
  -                    {_Actor1, Count1} ->
  -                        Acc andalso (Count < Count1)
  -                end
  -                end, true, PreviousList).
  +    %% Massive shortcut here -- get the value and see if it's different.
  +    riak_dt_gcounter:value(Previous) < riak_dt_gcounter:value(Current).
  +
  +ids_inflated(Previous, Current) ->
  +    lists:foldl(fun({Id, _}, Acc) ->
  +                        case lists:keyfind(Id, 1, Current) of
  +                            false ->
  +                                Acc andalso false;
  +                            _ ->
  +                                Acc andalso true
  +                        end
  +                end, true, Previous).
   
   -ifdef(TEST).
   
  
positive.code: threshold_met(riak_dt_gset, Value, Threshold) ->
      is_inflation(riak_dt_gset, Threshold, Value);
  
  threshold_met(riak_dt_gcounter, Value, {strict, Threshold}) ->
      Threshold < riak_dt_gcounter:value(Value);
  threshold_met(riak_dt_gcounter, Value, Threshold) ->
  
negative.code:     sets:is_subset(
          sets:from_list(riak_dt_gset:value(Previous)),
          sets:from_list(riak_dt_gset:value(Current)));
  
  is_lattice_inflation(riak_dt_orset, Previous, Current) ->
      lists:foldl(fun({Element, Ids}, Acc) ->
                          case lists:keyfind(Element, 1, Current) of
                              false ->
                                  Acc andalso false;
                              {_, Ids1} ->
                                  Acc andalso ids_inflated(Ids, Ids1)
                          end
                  end, true, Previous);
  
  is_lattice_inflation(riak_dt_gcounter, Previous, Current) ->
      PreviousList = lists:sort(orddict:to_list(Previous)),
  