anchor.diff:  
       schedule_build_graph(),
   
  -    {noreply, State#state{is_connected=IsConnected,
  +    {noreply, State#state{is_connected=Connected,
                             was_connected=WasConnected,
                             graph=Graph}};
   
  
positive.code:                end,
      Orphaned = sets:fold(GraphFun, [], Nodes),
  
      %% Verify connectedness.
      ConnectedFun = fun({Name, _, _}, Result0) ->
                             {Ns, Result} = sets:fold(fun({N, _, _}, {Disconnected, Result1}) ->
                                             Path = digraph:get_short_path(Graph, Name, N),
                                             case Path of
                                                 false ->
                                                     {[N|Disconnected], Result1 andalso false};
                                                 _ ->
                                                     {Disconnected, Result1 andalso true}
                                             end
                                        end, {[], Result0}, Nodes),
                             case Ns of
                                 [] ->
                                     ok;
                                 _ ->
                                  lager:info("Node ~p can not find shortest path to: ~p", [Name, Ns])
                             end,
                             Result
                   end,
      Connected = sets:fold(ConnectedFun, true, Nodes)
          andalso sets:size(ClientsFromMarathon) == lasp_config:get(client_number, 3),
  
      IsConnected = case Connected of
          true ->
              lager:info("Graph is connected!"),
              true;
          false ->
              lager:info("Graph is not connected!"),
              false
      end,
  
      WasConnected = IsConnected orelse WasConnected0,
  
      case length(Orphaned) of
          0 ->
  
negative.code:                         digraph:add_edge(Graph, Name, N)
                  end, Graph, Membership).
  
  breath_first(Root, Graph, Visited0) ->
      %% Check if every link is bidirectional
      %% If not, stop traversal
      In = ordsets:from_list(digraph:in_neighbours(Graph, Root)),
      Out = ordsets:from_list(digraph:out_neighbours(Graph, Root)),
  
      Visited1 = ordsets:union(Visited0, [Root]),
  
      case In == Out of
          true ->
              {SymmetricViews, VisitedNodes} = ordsets:fold(
                  fun(Peer, {SymmetricViews0, VisitedNodes0}) ->
                      {SymmetricViews1, VisitedNodes1} = breath_first(Peer, Graph, VisitedNodes0),
                      {SymmetricViews0 andalso SymmetricViews1, ordsets:union(VisitedNodes0, VisitedNodes1)}
                  end,
                  {true, Visited1},
                  ordsets:subtract(Out, Visited1)
              ),
  
              {SymmetricViews, ordsets:union(VisitedNodes, Out)};
          false ->
              {false, ordsets:new()}
      end.
  
  %% @private
  prefix(File) ->
      EvalTimestamp = lasp_config:get(evaluation_timestamp, 0),
  