for(int attempt=0;attempt<2;++attempt)

      {// try learning the same machine a few times

        LearnerGraph pta = new LearnerGraph(config);

        // test sequences will be distributed around

        // The total number of elements in test sequences (alphabet*states*traceQuantity) will be distributed around (random(pathLength)+1). The total size of PTA is a product of these two.

        // For the purpose of generating long traces, we construct as many traces as there are states but these traces have to be rather long,

        // that is, length of traces will be (random(pathLength)+1)*sequencesPerChunk/states and the number of traces generated will be the same as the number of states.

        final int tracesToGenerate = makeEven(states*traceQuantity);

        final Random rnd = new Random(seed*31+attempt);

                   

            @Override

            public int getLength() {

              return (rnd.nextInt(pathLength)+1)*lengthMultiplier;

            }

   

            @Override

            public int getPrefixLength(int len) {

              return len;

            }

          });

        /*

        for(List<Label> seq:referenceGraph.wmethod.computeNewTestSet(1))

        {

          pta.paths.augmentPTA(seq, referenceGraph.getVertex(seq) != null, false, null);

        }*/

        //pta.paths.augmentPTA(referenceGraph.wmethod.computeNewTestSet(referenceGraph.getInit(),1));// this one will not set any states as rejects because it uses shouldbereturned

        //referenceGraph.pathroutines.completeGraph(referenceGraph.nextID(false));

        if (onlyUsePositives)

            @Override

            public boolean shouldBeReturned(Object name) {

              return ((statechum.analysis.learning.rpnicore.RandomPathGenerator.StateName)name).accept;

            }

          }));

        else

          // In order to approximate the behaviour of our case study, we need to compute which pairs are not allowed from a reference graph and use those as if-then automata to start the inference.

         

        //pta.paths.augmentPTA(referenceGraph.wmethod.computeNewTestSet(referenceGraph.getInit(),1));

       

        pta.clearColours();

      for(int attempt=0;attempt<2;++attempt)

      {// try learning the same machine a few times

        LearnerGraph pta = new LearnerGraph(config);

        final int tracesToGenerate = makeEven(traceQuantity);

                   

            @Override

            public int getLength() {

              return (int)(traceLengthMultiplier*states*tracesAlphabet);

            }

   

            @Override

            public int getPrefixLength(int len) {

              return len;

            }

          });

        if (onlyUsePositives)

        {

            @Override

            public boolean shouldBeReturned(Object name) {

              return ((statechum.analysis.learning.rpnicore.RandomPathGenerator.StateName)name).accept;

            }

          }));

        }

        else

   

        final MarkovModel m= new MarkovModel(chunkLen,true,true);

        new MarkovClassifier(m, pta).updateMarkov(false);// construct Markov chain if asked for.

       

      for(int attempt=0;attempt<10;++attempt)

      {// try learning the same machine a few times

         LearnerGraph pta = new LearnerGraph(config);

        final int tracesToGenerate = makeEven(traceQuantity);

                   

            @Override

            public int getLength() {

              return (int) traceLengthMultiplier*alphabet*states;

            }

   

            @Override

            public int getPrefixLength(int len) {

              return len;

            }

          });

        if (onlyUsePositives)

        {

            @Override

            public boolean shouldBeReturned(Object name) {

              return ((statechum.analysis.learning.rpnicore.RandomPathGenerator.StateName)name).accept;

            }

          }));

        }

        else

        final MarkovModel m= new MarkovModel(chunkLen,true,true, disableInconsistenciesInMergers);

        new MarkovClassifier(m, pta).updateMarkov(false);// construct Markov chain if asked for.

       

       final Collection<List<Label>> wMethod = graphReference.wmethod.getFullTestSet(1);

       int wPos=0;

       for(List<Label> seq:wMethod) if (graphReference.paths.tracePathPrefixClosed(seq) == AbstractOracle.USER_ACCEPTED) wPos++;

       System.out.println("before rnd: "+wMethod.size()+" sequences, "+wPos+" positives");

       System.out.println("after rnd: "+wMethod.size()+" sequences");

      

      

       DrawGraphs gr = new DrawGraphs();

    final RBoxPlot<Integer>

    }

   

    {

      Collection<List<Label>> sequences =new LinkedHashSet<List<Label>>();

      long startTime = System.nanoTime();

      outcome.setValue(LONG_V.DURATION_RAND,System.nanoTime()-startTime);

      Pair<Double,Long> randSeq = compareLang(from, to, sequences);

      outcome.setValue(LONG_V.DURATION_RAND, outcome.getValue(LONG_V.DURATION_RAND)+randSeq.secondElem);

      outcome.setValue(DOUBLE_V.ACCURACY_RAND, randSeq.firstElem);

    }