protected boolean addEdgeInternal(DeterministicVertex v, DeterministicVertex random)

  {

    Set<Label> vertexAlphabet = new TreeSet<Label>();

    for (Object e : v.getOutEdges()) {

        existingEdge = edge;

      assert labels!=null : "vertex "+v.getID().toString()+" has outgoing edges without labels";

      vertexAlphabet.addAll(labels);

    }

    Set<Label> possibles = new TreeSet<Label>();

    possibles.addAll(alphabet);

    possibles.removeAll(vertexAlphabet);

    Label label = null;

    if(possibles.isEmpty())

      return false;// failure to add an edge since all possible letters of an alphabet have already been used

    Label possiblesArray [] = new Label[possibles.size()];possibles.toArray(possiblesArray);

    label = possiblesArray[randomInt(possiblesArray.length)];

    if (existingEdge != null)

    {// a parallel edge

      ((Set<Label>)existingEdge.getUserDatum(JUConstants.LABEL)).add(label);

    }

    else

    {// new edge needs to be added.

      try

      {

        Set<Label> labelSet = new TreeSet<Label>();

        labelSet.add(label);

        machine.addEdge(e);

      }

      catch(edu.uci.ics.jung.exceptions.ConstraintViolationException e1){

        Helper.throwUnchecked("poor constraints from"+v+" to "+random,e1);

      }

    Iterator<DirectedSparseEdge> edgeIter = g.getEdges().iterator();

    while(edgeIter.hasNext())

    { 

      // The line below aims to ensure that inputs are evaluated by computeStateScore in a specific order, which in conjunction with the visited set of computeStateScore permits emulating a bug in computeScore

    }

   

    PairCompatibility<Vertex> compat = (PairCompatibility<Vertex>)g.getUserDatum(JUConstants.PAIR_COMPATIBILITY);

    if (compat != null)

      PairCompatibility.copyTo(compat, pairCompatibility, origToCmp);

    Iterator<DirectedSparseEdge> edgeIter = g.getEdges().iterator();

    while(edgeIter.hasNext())

    { 

      // The line below aims to ensure that inputs are evaluated by computeStateScore in a specific order, which in conjunction with the visited set of computeStateScore permits emulating a bug in computeScore

    }

   

    PairCompatibility<Vertex> compat = (PairCompatibility<Vertex>)g.getUserDatum(JUConstants.PAIR_COMPATIBILITY);

    if (compat != null)

      PairCompatibility.copyTo(compat, pairCompatibility, origToCmp);

  }

 

  /** Adds an edge between the supplied vertices and returns true/false if this was successful. */

  protected boolean addEdge(DeterministicVertex v, DeterministicVertex w) {

  }

    List<DeterministicVertex> result = new LinkedList<DeterministicVertex>();

    Iterator<DirectedSparseEdge> inIt = ambassador.getInEdges().iterator();

    Set<DeterministicVertex> verticesToChooseFrom = new TreeSet<DeterministicVertex>();

    while(inIt.hasNext()){

      if(!visited.contains(v))

        verticesToChooseFrom.add(v);

    }

    if (!verticesToChooseFrom.isEmpty()) result.addAll(selectVertices(verticesToChooseFrom, x));

   

    Iterator<DirectedSparseEdge> outIt = ambassador.getOutEdges().iterator();

    verticesToChooseFrom.clear();

    while(outIt.hasNext()){

      if(!visited.contains(v))

        verticesToChooseFrom.add(v);

    }

   

    if (!verticesToChooseFrom.isEmpty()) result.addAll(selectVertices(verticesToChooseFrom, y));

        Iterator<DirectedSparseEdge> sourceOutIt = source.getOutEdges().iterator();

        Edge fromSourceToNewRed = null;

        while(sourceOutIt.hasNext() && fromSourceToNewRed == null)

        {

        }

        if (fromSourceToNewRed == null)

        {

          fromSourceToNewRed.setUserDatum(JUConstants.LABEL, existingLabels, UserData.CLONE);// no need to clone this one since I'll delete the edge in a bit

          g.addEdge(fromSourceToNewRed);

        }

        else

          // there is already a transition from source to newRed, hence all we have to do is merge the new labels into it.

          ((Collection<String>)fromSourceToNewRed.getUserDatum(JUConstants.LABEL)).addAll( existingLabels );

         

      }

      // now the elements of mergedVertices are in terms of the copied graph.

      for(Vertex vert:(Set<Vertex>)g.getVertices())

        if (mergedVertices.containsKey(vert))

        {// there are some vertices to merge with this one.

          usedInputs.clear();usedInputs.addAll(s.transitionMatrix.get(vert).keySet());

          for(CmpVertex toMerge:mergedVertices.get(vert))

          {// for every input, I'll have a unique target state - this is a feature of PTA

           // For this reason, every if multiple branches of PTA get merged, there will be no loops or parallel edges.

          // As a consequence, it is safe to assume that each input/target state combination will lead to a new state.

            Set<String> inputsFrom_toMerge = s.transitionMatrix.get(toMerge).keySet();

            for(String input:inputsFrom_toMerge)

              if (!usedInputs.contains(input))

              {

                Set<String> labels = new HashSet<String>();labels.add(input);

                DeterministicVertex targetVert = (DeterministicVertex)s.transitionMatrix.get(toMerge).get(input);

                g.removeEdges(targetVert.getInEdges());g.addEdge(newEdge);

              }

            usedInputs.addAll(inputsFrom_toMerge);

          }

        }

    for(Vertex v: DeterministicDirectedSparseGraph.findVertices(JUConstants.COLOUR, JUConstants.RED, model))

    {

      Iterator<DirectedSparseEdge>neighbourIt = v.getOutEdges().iterator();

      while(neighbourIt.hasNext()){

        JUConstants neighbourColour = (JUConstants)neighbour.getUserDatum(JUConstants.COLOUR);

        if(neighbourColour!=null){

          if(neighbourColour == JUConstants.RED)

            continue;

        }

 

  public static boolean hasAcceptedNeighbours(Vertex v){

    Iterator<DirectedSparseEdge> neighbourIt = v.getOutEdges().iterator();

    while (neighbourIt.hasNext()){

      if(DeterministicDirectedSparseGraph.isAccept(to))

        return true;

    }

    return false;

  }

    Vertex qDash = pair.getR();

    Iterator<DirectedSparseEdge> inEdges = q.getInEdges().iterator();

    Set<DirectedSparseEdge> removeEdges = new HashSet<DirectedSparseEdge>();

    while(inEdges.hasNext()){

      if(!e.getSource().getSuccessors().contains(qDash))

        model.addEdge(eDash);

      else{

        Edge existing = findEdge(e.getSource(), qDash);

        Set<String> labels = (Set<String>)existing.getUserDatum(JUConstants.LABEL);// KIRR: if you use UserData.SHARED, you do not need to copy the result back using put

        labels.addAll((Set<String>)e.getUserDatum(JUConstants.LABEL));

        existing.setUserDatum(JUConstants.LABEL, labels, UserData.CLONE);

      }

      removeEdges.add(e);

    }

    Iterator<DirectedSparseEdge> outEdges = q.getOutEdges().iterator();

    while(outEdges.hasNext()){

      if(!qDash.getSuccessors().contains(e.getDest()))

        model.addEdge(eDash);

      else{

        Edge existing = findEdge(qDash, e.getDest());

        Set<String> labels = (Set<String>)existing.getUserDatum(JUConstants.LABEL);

        Iterator<DirectedSparseEdge> sourceOutIt = source.getOutEdges().iterator();

        Edge fromSourceToNewRed = null;

        while(sourceOutIt.hasNext() && fromSourceToNewRed == null)

        {

        }

        if (fromSourceToNewRed == null)

        {

          fromSourceToNewRed.setUserDatum(JUConstants.LABEL, existingLabels, UserData.CLONE);// no need to clone this one since I'll delete the edge in a bit

          g.addEdge(fromSourceToNewRed);

        }

        else

          // there is already a transition from source to newRed, hence all we have to do is merge the new labels into it.

          ((Collection<Label>)fromSourceToNewRed.getUserDatum(JUConstants.LABEL)).addAll( existingLabels );

         

      }

      // now the elements of mergedVertices are in terms of the copied graph.

      for(Vertex vert:(Set<Vertex>)g.getVertices())

        if (mergedVertices.containsKey(vert))

        {// there are some vertices to merge with this one.

          usedInputs.clear();usedInputs.addAll(s.transitionMatrix.get(vert).keySet());

          for(CmpVertex toMerge:mergedVertices.get(vert))

          {// for every input, I'll have a unique target state - this is a feature of PTA

           // For this reason, every if multiple branches of PTA get merged, there will be no loops or parallel edges.

          // As a consequence, it is safe to assume that each input/target state combination will lead to a new state.

            Set<Label> inputsFrom_toMerge = s.transitionMatrix.get(toMerge).keySet();

            for(Label input:inputsFrom_toMerge)

              if (!usedInputs.contains(input))

              {

                Set<Label> labels = new HashSet<Label>();

                                                                labels.add(input);

                DeterministicVertex targetVert = (DeterministicVertex)s.transitionMatrix.get(toMerge).get(input);

                g.removeEdges(targetVert.getInEdges());g.addEdge(newEdge);

              }

            usedInputs.addAll(inputsFrom_toMerge);

          }

        }