anchor.diff:  schedule_valid_causality(Causality, CandidateTrace0) ->
       CandidateTrace = message_types(CandidateTrace0),
   
  -    % debug("derived_schedule: ~p~n", [length(DerivedSchedule)]),
  -    % debug("prefix_schedule: ~p~n", [length(PrefixSchedule)]),
  -    % debug("omitted_schedule: ~p~n", [length(OmittedSchedule)]),
  -    % debug("conditional_schedule: ~p~n", [length(ConditionalSchedule)]),
  +    % debug("CandidateTrace: ~p~n", [CandidateTrace]),
  +    % debug("Causality: ~p~n", [dict:to_list(Causality)]),
   
       RequirementsMet = lists:foldl(fun(Type, Acc) ->
           % debug("=> Type: ~p~n", [Type]),
   
  -        All = lists:foldl(fun({K, V}, Acc1) ->
  +        {AtLeastOneDependency, SatifyingDependency} = lists:foldl(fun({K, V}, {_AtLeastOne, Found}) ->
               % debug("=> V: ~p~n", [V]),
   
  -            case lists:member(Type, V) of 
  +            case Found of 
                   true ->
  -                    % debug("=> Presence of ~p requires: ~p~n", [Type, K]),
  -
  -                    SearchType = case K of 
  -                        {receive_message, T} ->
  -                            {forward_message, T};
  -                        Other ->
  -                            Other
  -                    end,
  -
  -                    % debug("=> Rewriting to look for send of same message type: ~p~n", [SearchType]),
  -
  -                    case lists:member(SearchType, CandidateTrace) of 
  +                    % debug("=> already found satisfying dependency for ~p, not checking further~n", [Type]),
  +                    {true, true};
  +                false ->
  +                    case lists:member(Type, V) of 
                           true ->
  -                            % debug("=> Present!~n", []),
  -                            true andalso Acc1;
  +                            % debug("=> Presence of ~p requires: ~p~n", [Type, K]),
  +
  +                            SearchType = case K of 
  +                                {receive_message, T} ->
  +                                    {forward_message, T};
  +                                Other ->
  +                                    Other
  +                            end,
  +
  +                            % debug("=> Rewriting to look for send of same message type: ~p~n", [SearchType]),
  +
  +                            case lists:member(SearchType, CandidateTrace) of 
  +                                true ->
  +                                    % debug("=> Present!~n", []),
  +                                    {true, true};
  +                                false ->
  +                                    % debug("=> NOT Present!~n", []),
  +                                    {true, false}
  +                            end;
                           false ->
  -                            % debug("=> NOT Present!~n", []),
  -                            false andalso Acc1
  -                    end;
  -                false ->
  -                    % debug("=> * fallthrough: ~p not in ~p.~n", [Type, V]),
  -                    true andalso Acc1
  +                            % debug("=> * fallthrough: ~p not in ~p.~n", [Type, V]),
  +                            {false, false}
  +                    end
               end
  -        end, Acc, dict:to_list(Causality)),
  -
  -        All andalso Acc
  +        end, {false, false}, dict:to_list(Causality)),
  +
  +        case AtLeastOneDependency of 
  +            true ->
  +                %% We searched at least once, but didn't find one.
  +                SatifyingDependency andalso Acc;
  +            false ->
  +                %% This message has no dependencies, therefore it can always occur.
  +                Acc
  +        end
       end, true, CandidateTrace),
   
       case RequirementsMet of 
  
positive.code:             case Precondition of 
                  {PreconditionType, N} ->
                      Num = length(lists:filter(fun(T) -> T =:= PreconditionType end, DerivedSchedule)),
                      debug("=> * found ~p messages of type ~p~n", [Num, PreconditionType]),
                      Acc andalso Num >= N;
                  true ->
                      debug("=> * found true precondition", []),
                      Acc andalso true
              end
          end, true, Preconditions),
  
          debug("=> type: ~p, preconditions: ~p~n", [Type, Result]),
          dict:store(Type, Result, Dict0)
      end, dict:new(), dict:to_list(CausalityAnnotations)),
  
      debug("classification: ~p~n", [dict:to_list(Classification)]),
  
      Classification.
  
  
negative.code: 
  %% @private
  classify_schedule(_N, CausalityAnnotations, PrefixSchedule, _OmittedSchedule, ConditionalSchedule) ->
      % debug("classifying schedule using causality annotations: ~p", [dict:to_list(CausalityAnnotations)]),
  
      DerivedSchedule = PrefixSchedule ++ ConditionalSchedule,
  
  