anchor.diff:                       PageIs = lists:zip(Pages, lists:seq(1, length(Pages))),
                        TS2 = event_logger:timestamp(),
                        [begin
  -                          PidI = {self(), I},
  +                          PidI = {self(), s_f, I},
                             event_logger:event(log_make_call(PidI, {read, LPN}),
                                                TS1),
                             Pm = perhaps_trip_scan_forward(
  
positive.code:     %% that time in the relation.
      %% The key for OD is LPN, the value is an unordered list of possible values.
  
      InitialDict = orddict:from_list([{LPN, [error_unwritten]} ||
                                          LPN <- AllLPNs]),
      {ValuesR, _} =
          lists:mapfoldl(
            fun({TS1, TS2, StEnds}, Dict1) ->
                    Dict2 = lists:foldl(
                              fun({m_start, LPN, Pg}, D) ->
                                      orddict:append(LPN, Pg, D)
                              end, Dict1, [X || X={m_start,_,_} <- StEnds]),
                    Dict3 = lists:foldl(
                              fun({m_end, LPN, Pg}, D) ->
                                      orddict:store(LPN, [Pg], D)
                              end, Dict2, [X || X={m_end,_,_} <- StEnds]),
                    {{TS1, TS2, [{values, Dict3}]}, Dict3}
            end, InitialDict, StartsDones),
  
      %% We want to find & fail any two clients that append the exact same page
      %% data to the same LPN.  Unfortunately, the eqc_temporal library will
      %% merge two such facts together into a single fact.  So this method
      %% commented below isn't good enough.
      %% M_Ends = eqc_temporal:at(infinity, eqc_temporal:any_past(DoneMod)),
      %% AppendedLPNs = lists:sort([LPN || {m_end, LPN, _} <- M_Ends]),
      %% {_Last, DuplicateLPNs} = lists:foldl(fun(X, {X, Dups}) -> {X, [X|Dups]};
      %%                                         (X, {_, Dups}) -> {X, Dups}
      %%                                      end, {undefined, []}, AppendedLPNs),
      AppendWillBes = [LPN || {_TS, {call, _, {append, _, will_be, LPN}}} <- Trace],
      DuplicateLPNs = AppendWillBes -- lists:usort(AppendWillBes),
  
      %% Checking reads is a tricky thing.  My first attempt created a temporal
      %% relation for the 1usec window when the read call was complete, then
  
negative.code:     [{Beginning, to, Next-1}|range_ify(Else, Else+1, T)];
  range_ify(Beginning, Next, []) ->
      [{Beginning, to, Next-1}].
  
  filter_relation_facts(FilterFun, R) ->
      [{TS1, TS2, lists:filter(FilterFun, Facts)} || {TS1, TS2, Facts} <- R].
          %% {TS1, TS2, Facts} <- Reads, Fact <- Facts, BadFilter(Fact)],
  
  log_make_call(Tag) ->
      log_make_call(self(), Tag).
  