new MarkovClassifier(mOther,graph).updateMarkov(false);

    Assert.assertEquals(m.predictionsMatrix,mOther.predictionsMatrix);

   

    // Workaround around a deficiency in the calculation of occurrences of prefixes by the PTA-based construction of Markov model.

   

    Assert.assertEquals(m.occurrenceMatrix,mOther.occurrenceMatrix);

  }

    MarkovModel m = new MarkovModel(2,false,true);

    new MarkovClassifier(m,graph).updateMarkov(true);

    Assert.assertEquals(4,m.predictionsMatrix.size());

    Assert.assertEquals(4,m.occurrenceMatrix.size());

  }

    final LearnerGraph graph = FsmParser.buildLearnerGraph("A-a->B-a->C / B-b->C","testUpdateMarkovSideways1",config, converter);

    MarkovModel m = new MarkovModel(2,false,true);

    new MarkovClassifier(m,graph).updateMarkov(false);

    Assert.assertEquals(6,m.predictionsMatrix.size());

  }

    MarkovModel m = new MarkovModel(2,false,true);

    new MarkovClassifier(m,graph).updateMarkov(false);

    Assert.assertEquals(9,m.predictionsMatrix.size());

  }

    final LearnerGraph graph = FsmParser.buildLearnerGraph("A-a->B-a->C / B-b->C-a-#D / B-c-#D","testUpdateMarkovSideways1c",config, converter);

    MarkovModel m = new MarkovModel(2,true,true);

    new MarkovClassifier(m,graph).updateMarkov(false);

    Assert.assertEquals(7,m.predictionsMatrix.size());

   

    Set<List<Label>> plusStrings = buildSet(new String[][] {},config,converter), minusStrings = buildSet(new String[][] { new String[]{"a","a","a"},new String[]{"a","b","a"},new String[]{"a","c"} },config,converter);

    MarkovModel another = new MarkovModel(2,true,true);

    another.createMarkovLearner(plusStrings, minusStrings, false);

    Assert.assertEquals(7,another.predictionsMatrix.size());

  }

    final LearnerGraph graph = FsmParser.buildLearnerGraph("A-a->B-c->C / B-b-#D","testUpdateMarkovSideways2",config, converter);

    MarkovModel m = new MarkovModel(2,false,true);

    new MarkovClassifier(m,graph).updateMarkov(true);

    Assert.assertEquals(3,m.predictionsMatrix.size());

  }

    final LearnerGraph graph = FsmParser.buildLearnerGraph("A-a->B-b->C / B-u-#D / A-c->E-u->F / E-c->G","testUpdateMarkovSideways3",config, converter);

    MarkovModel m = new MarkovModel(2,false,true);

    new MarkovClassifier(m,graph).updateMarkov(true);

    Assert.assertEquals(9,m.predictionsMatrix.size());

   

   

  }

    final LearnerGraph graph = FsmParser.buildLearnerGraph("A-a->B-b->C / B-u-#D / A-c->E-u->F / E-c->G","testUpdateMarkovSideways3",config, converter);

    MarkovModel m = new MarkovModel(3,false,true);

    new MarkovClassifier(m,graph).updateMarkov(true);

    Assert.assertEquals(6,m.predictionsMatrix.size());

   

   

  }

    new MarkovClassifier(m,graph).updateMarkov(true);

   

    Assert.assertEquals(8,m.predictionsMatrix.size());

   

   

   

  }

    // going through all positive traces

    //and partitioning each positive traces into a list of events ( a list of labels based on the chunk length)

    for(List<Label> positive_trace:pos)

    {

      for(int i=onlyLongest?chunk_Length-1:0;i<chunk_Length;i++)

      {

        List<Trace> List_traces=splitTrace(current_positive_trace,i+1);

        for (Trace tracePos:List_traces)

          updateOccurrenceMatrix(tracePos,true);

      }

    }

   

    // from negative traces initialize the Markov matrix

    for(List<Label> negative_trace:neg)

    {

      for(int i=onlyLongest?chunk_Length-1:0; i<chunk_Length; i++)

      {

        List<Trace> List_traces=splitTrace(trace,i+1);

        int chunkNumber = List_traces.size();

        if (chunkNumber >= 1)

        {

          updateOccurrenceMatrix(traceNeg,false);

          for (Trace tracePos:List_traces)

            if (tracePos != traceNeg)

              updateOccurrenceMatrix(tracePos,true);

        }

      }

    }

   

    // Construct a matrix from trace data, including marking of conflicting data as invalid (conflicts arise where a path is too short).

    // A prefix of either a positive/ a negative/ a failure (where there are some states from which a shorter sequence is rejected but from other states a longer one is accepted).

    for (Entry<Trace, UpdatablePairInteger> e : occurrenceMatrix.entrySet())

    {

      trace_to_account_its_probability=e.getKey();

      UpdatablePairInteger Trace_occurence = e.getValue();

      if (Trace_occurence.firstElem > 0 && Trace_occurence.secondElem > 0)