// Special configuration is necessary to ensure that computePairCompatibilityScore_internal

      // builds mergedVertices using g's vertices rather than StringVertices or clones of g's vertices.

      Configuration VertexCloneConf = (Configuration)conf.clone();VertexCloneConf.setLearnerUseStrings(false);VertexCloneConf.setLearnerCloneGraph(false);

      LearnerGraph s=new LearnerGraph(g,VertexCloneConf);

        throw new IllegalArgumentException("elements of the pair are incompatible");

      // make a loop

      Set<String> usedInputs = new HashSet<String>();

      for(DirectedSparseEdge e:(Set<DirectedSparseEdge>)newBlue.getInEdges())

      // Special configuration is necessary to ensure that computePairCompatibilityScore_internal

      // builds mergedVertices using g's vertices rather than StringVertices or clones of g's vertices.

      Configuration VertexCloneConf = conf.copy();VertexCloneConf.setLearnerUseStrings(false);VertexCloneConf.setLearnerCloneGraph(false);

      LearnerGraph s=new LearnerGraph(g,VertexCloneConf);

        throw new IllegalArgumentException("elements of the pair are incompatible");

      // make a loop

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

      for(DirectedSparseEdge e:(Set<DirectedSparseEdge>)newBlue.getInEdges())

        CmpVertex prevVertex = null;

        for(CmpVertex v:vertices)

        {

          if (prevVertex != null)

          prevVertex = v;

        }

      }

      for(Collection<CmpVertex> vertices:labelFromStates.values())

      {

        CmpVertex prevVertex = null;

        for(CmpVertex v:vertices)

        {

          if (prevVertex != null)

          prevVertex = v;

        }

      }

      /*

      LinkedList<AMEquivalenceClass<CmpVertex,LearnerGraphCachedData>> verticesToMerge = new LinkedList<AMEquivalenceClass<CmpVertex,LearnerGraphCachedData>>();

        "A3-c->A31-c->A32 / A31-d-#A34 /"+

        "A4-c->A41-c->A42-f-#A43 /"+

        "A5-c->A51-c->A52"

        , "testBuildPTAofQuestions1",config,converter);

    LearnerGraph merged = MergeStates.mergeAndDeterminize_general(graph, pair);

    compareGraphs(buildLearnerGraph("A1-a->B1-b->A1-c->C-d-#R4 / C-c->CC / CC-f-#R3 / CC-e->D", "expected",config,converter),merged);

    PTASequenceEngine questions = ComputeQuestions.getQuestionPta(pair, graph, merged, null);

    LearnerGraph updatedGraphExpected = new LearnerGraph(graph,config),

      updatedGraphActual = ComputeQuestions.constructGraphWithQuestions(pair, graph, merged);

  private void checkQuestionAugmentation(String fsm, String name)

  {

    Configuration config = mainConfiguration.copy();config.setLearnerCloneGraph(false);

    LearnerGraph graph = buildLearnerGraph(fsm,name,config,converter);

    LearnerGraph merged = MergeStates.mergeAndDeterminize_general(graph, pair);

    PTASequenceEngine questions = ComputeQuestions.computeQS_general(pair, graph, merged, new ComputeQuestions.QSMQuestionGenerator());

    LearnerGraph updatedGraphExpected = new LearnerGraph(graph,config),updatedGraphActual = new LearnerGraph(graph,config);

    updatedGraphActual.transitionMatrix.putAll(((NonExistingPaths)questions.getFSM()).getNonExistingTransitionMatrix());

    updatedGraphActual.learnerCache.invalidate();

        "A3-c->A31-c->A32 / A31-d-#A34 /"+

        "A4-c->A41-c->A42-f-#A43 /"+

        "A5-c->A51-c->A52"

        , "testBuildPTAofQuestions1",mainConfiguration,converter);

    LearnerGraph merged = MergeStates.mergeAndDeterminize_general(graph, pair);

    compareGraphs(buildLearnerGraph("A1-a->B1-b->A1-c->C-d-#R4/C-c->CC/CC-f-#R3/CC-e->D", "testQuestionAnswering2b",mainConfiguration,converter),merged);

    PTASequenceEngine questions = ComputeQuestions.computeQS_general(pair, graph, merged, new ComputeQuestions.QSMQuestionGenerator());

    // the IF part we're augmenting with is a dummy one

    LearnerGraph[] ifthenCollection = new LearnerGraph[]{buildLearnerGraph("A-s->B / P-c->Q-d-#R / S-c->S1-c->S2-e->S3 / S==THEN==A==THEN==P", "testQuestionAnswering1", mainConfiguration,converter)};

  public static List<List<String>> computeQS(final StatePair pair, LearnerGraph original, LearnerGraph merged)

  {

    List<List<String>> result = null;

    if (original.config.getQuestionGenerator() == Configuration.QuestionGeneratorKind.ORIGINAL)

    else

    {

      QuestionConstructor qConstructor=null;

      switch(original.config.getQuestionGenerator())

      {

      // Special configuration is necessary to ensure that computePairCompatibilityScore_internal

      // builds mergedVertices using g's vertices rather than StringVertices or clones of g's vertices.

      Configuration VertexCloneConf = conf.copy();VertexCloneConf.setLearnerUseStrings(false);VertexCloneConf.setLearnerCloneGraph(false);

      LearnerGraph s=new LearnerGraph(g,VertexCloneConf);

        throw new IllegalArgumentException("elements of the pair are incompatible");

      // make a loop

      Set<String> usedInputs = new HashSet<String>();

      for(DirectedSparseEdge e:(Set<DirectedSparseEdge>)newBlue.getInEdges())

      currentExplorationBoundary.add(pair);currentExplorationBoundary.offer(null);

     

      while(!foundKTail)

      {

        if (currentPair == null)

        {// we got to the end of a wave

          if (currentExplorationBoundary.isEmpty())

            break;// we are at the end of the last wave, stop looping.

          // mark the end of a wave.

          currentExplorationBoundary.offer(null);

        }

        else

        {

   

          for(Entry<Label,CmpVertex> redEntry:targetRed.entrySet())

          {

            CmpVertex nextBlueState = targetBlue.get(redEntry.getKey());

            if (nextBlueState != null)

            {// both states can make a transition

              if (!AbstractLearnerGraph.checkCompatible(redEntry.getValue(),nextBlueState,coregraph.pairCompatibility))

                return -1;// incompatible states

             

//              if(RPNIUniversalLearner.state_outgoing.get(currentPair.getQ())==null || RPNIUniversalLearner.state_outgoing.get(currentPair.getQ()).get(redEntry.getKey())==null)

                 matchscore++;

             

//                           matchscore++;

             

             

              currentExplorationBoundary.offer(nextStatePair);

              }               

            // if the red can make a move, but the blue one cannot, ignore this case.

          }

        }

  public final void testCheckGraphNumeric3()

  {

    LearnerGraph textGraph = new LearnerGraph(buildGraph("A-a->A-c->C","testCheckGraphNumeric"),config);

    LearnerGraph numericGraph = new LearnerGraph(config);CmpVertex newInit = Transform.addToGraph(numericGraph, textGraph);

    Assert.assertTrue(numericGraph.wmethod.checkGraphNumeric());

  }