anchor.diff:                          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),
  
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: 
      schedule_build_graph(),
  
      {noreply, State#state{is_connected=Connected,
                            was_connected=WasConnected,
                            graph=Graph}};
  
  