anchor.diff:                      true ->
                           Acc andalso true;
                       false ->
  -                        debug("Precondition not found for message type: ~p~n", [Message]),
  +                        % debug("Precondition not found for message type: ~p~n", [Message]),
                           Acc andalso false
                   end
           end
  
positive.code: 
  %% @private
  classify_schedule(_N, CausalityAnnotations, PrefixSchedule, _OmittedSchedule, ConditionalSchedule) ->
      debug("classifying schedule using causality annotations: ~p", [dict:to_list(CausalityAnnotations)]),
  
      DerivedSchedule = PrefixSchedule ++ ConditionalSchedule,
  
  
negative.code: %% @private
  schedule_valid_causality(Causality, PrefixSchedule, _OmittedSchedule, ConditionalSchedule) ->
      DerivedSchedule = PrefixSchedule ++ ConditionalSchedule,
      % debug("length(DerivedSchedule): ~p~n", [length(DerivedSchedule)]),
      % debug("length(PrefixSchedule): ~p~n", [length(PrefixSchedule)]),
      % debug("length(OmittedSchedule): ~p~n", [length(OmittedSchedule)]),
      % debug("length(ConditionalSchedule): ~p~n", [length(ConditionalSchedule)]),
      % debug("Causality: ~p~n", [dict:to_list(Causality)]),
  
      RequirementsMet = lists:foldl(fun(Type, Acc) ->
          % debug("=> Type: ~p~n", [Type]),
  
          {AtLeastOneDependency, SatifyingDependency} = lists:foldl(fun({K, V}, {_AtLeastOne, Found}) ->
              % debug("=> V: ~p~n", [V]),
  
              case Found of 
                  true ->
                      % debug("=> already found satisfyng dependency for ~p, not checking further~n", [Type]),
                      {true, true};
                  false ->
                      case lists:member(Type, V) of 
                          true ->
                              % debug("=> Presence of ~p requires: ~p~n", [Type, K]),
  
                              case lists:member(K, DerivedSchedule) of 
                                  true ->
                                      % debug("=> Present!~n", []),
                                      {true, true};
                                  false ->
                                      % debug("=> NOT Present!~n", []),
                                      {true, false}
                              end;
                          false ->
                              % debug("=> * fallthrough: ~p not in ~p.~n", [Type, V]),
                              {false, false}
                      end
              end
          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, DerivedSchedule),
  
      case RequirementsMet of 
          true ->
              debug("Causality verified.~n", []),
              ok;
          false ->
              debug("Schedule does not represent a valid schedule!~n", []),
              ok
      end,
  
  