anchor.diff:                      read :: function(),
                       transform :: function(),
                       write :: function()}).
  +
  +%% @todo For now, maybe changed for another data structure
  +-record(vertex_label, {pointer_pid :: pid()}).
   
   -type lasp_vertex() :: id() | pid().
   
  
positive.code: %%      where ( . ) is defined as the usual composition operator.
  %%      The result of this operation is a new edge h = (v1, v3).
  %%
  contract(G, VSeq) ->
      [First, Second | _] = VSeq,
      Last = lists:last(VSeq),
  
negative.code: %%      we have to know when it happens so we can delete the appropiate
  %%      edges in the graph.
  %%
  handle_info({'DOWN', _, process, Pid, _Reason}, #state{dag=Dag,
                                                         process_map=PM,
                                                         optimized_map=OptMap}=State) ->
      {ok, Edges} = dict:find(Pid, PM),
      NewDag = lists:foldl(fun({F, T}, G) ->
          delete_with_pid(G, F, T, Pid)
      end, Dag, Edges),
  
      %% @todo Update the tags in the unnecessary vertices.
      {noreply, State#state{dag=NewDag,
                            process_map=dict:erase(Pid, PM),
                            optimized_map=dict:erase(Pid, OptMap)}};
  
  handle_info({process_created, Pid, VSeq}, #state{dag=Dag, optimized_map=OptMap}=State) ->
      %% @todo Assume the dag didn't change since last call.
      %%       Test it once the cleaving has been implemented.
      %%
      %%       If data races happen even with the cleaving step, we should
      %%       perform a check here, before removing the edges.
      %%
      NewOptMap = remove_edges(Dag, VSeq, Pid, OptMap),
      {noreply, State#state{optimized_map = NewOptMap}};
  
  handle_info(Msg, State) ->
      _ = lager:warning("Unhandled messages ~p", [Msg]),
  