some more cleanups

* Simplify the `initialSuffixes()` and `initialPrefixes()` methods in the LStar algorithm by finalizing them in the parent class (they can be set via constructor)
* Remove the `isOmegaCounterExample` method on `LassOracle`s which had very limited possibilities to make that decision (a boolean parameter). Instead this problem should be addressed in the `findCounterexample`/`processInput` methods directly.

Author: mtf90

CHANGELOG.md

@@ -17,11 +17,13 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
   * The `ParallelOracleBuilders` factory now offers builder methods for `SUL`s, `ObservableSUL`s, `StateLocalInputSUL`s, `MembershipOracles`s and `OmegaMembershipOracle`s to allow an easy (and correct) construction of parallel setups given one of the mentioned implementations.
 * Refactored the following packages/classes:
   * `de.learnlib.oracle.parallelism.ParallelOracleInterruptedException` -> `de.learnlib.api.oracle.parallelism.BatchInterruptedException`
+* The `initialPrefixes` and `initialSuffixes` methods of `AbstractExtensibleAutomatonLStar` are now `final` since these values can be provided via the constructor of the class. This allows one to simplify sub-classes.
 
 ### Removed
 
 * Removed the `learnlib.queries.parallel.threshold` property. Learning setups that want to use parallelism now need to explicitly setup parallel oracles.
 * Removed `MQUtil#answerQueries{Auto,Parallel}` and `MQUtil#answerOmegaQueries{Auto,Parallel}`)
+* `LassoOracle#isOmegaCounterExample(boolean)` has been removed. This decision can be directly integrated into the `#findCounterExample` method which has more information available.
 * Updated to [AutomataLib 0.10.0](https://github.com/LearnLib/automatalib/releases/tag/automatalib-0.10.0)
 
 ### Fixed

algorithms/active/lstar/src/main/java/de/learnlib/algorithms/lstar/AbstractExtensibleAutomatonLStar.java

@@ -59,12 +59,12 @@ protected void refineHypothesisInternal(DefaultQuery<I, D> ceQuery) {
     }
 
     @Override
-    protected List<Word<I>> initialPrefixes() {
+    protected final List<Word<I>> initialPrefixes() {
         return initialPrefixes;
     }
 
     @Override
-    protected List<Word<I>> initialSuffixes() {
+    protected final List<Word<I>> initialSuffixes() {
         return initialSuffixes;
     }
 

algorithms/active/lstar/src/main/java/de/learnlib/algorithms/lstar/ce/ObservationTableCEXHandlers.java

@@ -45,13 +45,13 @@ public <RI, RD> List<List<Row<RI>>> handleCounterexample(DefaultQuery<RI, RD> ce
                 }
 
                 @Override
-                public String toString() {
-                    return "ClassicLStar";
+                public boolean needsConsistencyCheck() {
+                    return true;
                 }
 
                 @Override
-                public boolean needsConsistencyCheck() {
-                    return true;
+                public String toString() {
+                    return "ClassicLStar";
                 }
 
             };

algorithms/active/lstar/src/main/java/de/learnlib/algorithms/lstar/dfa/ExtensibleLStarDFA.java

@@ -77,11 +77,6 @@ public ExtensibleLStarDFA(Alphabet<I> alphabet,
               closingStrategy);
     }
 
-    @Override
-    protected List<Word<I>> initialSuffixes() {
-        return Collections.singletonList(Word.epsilon());
-    }
-
     @Override
     protected DFA<?, I> exposeInternalHypothesis() {
         return internalHyp;

algorithms/active/lstar/src/main/java/de/learnlib/algorithms/lstar/mealy/ClassicLStarMealy.java

@@ -15,7 +15,6 @@
  */
 package de.learnlib.algorithms.lstar.mealy;
 
-import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
@@ -99,16 +98,6 @@ public static <I, O> ClassicLStarMealy<I, O> createForWordOracle(Alphabet<I> alp
         return new ClassicLStarMealy<>(alphabet, MealyUtil.wrapWordOracle(oracle), cexHandler, closingStrategy);
     }
 
-    @Override
-    protected List<Word<I>> initialSuffixes() {
-        List<Word<I>> suffixes = new ArrayList<>(alphabet.size());
-        for (int i = 0; i < alphabet.size(); i++) {
-            I sym = alphabet.getSymbol(i);
-            suffixes.add(Word.fromLetter(sym));
-        }
-        return suffixes;
-    }
-
     @Override
     protected MealyMachine<?, I, ?, O> exposeInternalHypothesis() {
         return internalHyp;
@@ -141,8 +130,6 @@ protected O transitionProperty(ObservationTable<I, @Nullable O> table, Row<I> st
                 }
                 return wordOut.lastSymbol();
             }
-
         };
     }
-
 }

algorithms/active/lstar/src/main/java/de/learnlib/algorithms/lstar/mealy/ExtensibleLStarMealy.java

@@ -65,11 +65,6 @@ public ExtensibleLStarMealy(Alphabet<I> alphabet,
               closingStrategy);
     }
 
-    @Override
-    protected List<Word<I>> initialSuffixes() {
-        return initialSuffixes;
-    }
-
     @Override
     public CompactMealy<I, O> getHypothesisModel() {
         return internalHyp;

api/src/main/java/de/learnlib/api/oracle/LassoEmptinessOracle.java

@@ -33,18 +33,6 @@
  */
 public interface LassoEmptinessOracle<L extends Lasso<I, D>, I, D> extends EmptinessOracle<L, I, D> {
 
-    /**
-     * Return that when a lasso is ultimately periodic, it could serve as a counter example.
-     *
-     * @param isUltimatelyPeriodic
-     *          whether the lasso is ultimately periodic
-     *
-     * @return true when a lasso is ultimately periodic, false otherwise.
-     */
-    default boolean isOmegaCounterExample(boolean isUltimatelyPeriodic) {
-        return isUltimatelyPeriodic;
-    }
-
     interface DFALassoEmptinessOracle<I> extends LassoEmptinessOracle<DFALasso<I>, I, Boolean> {}
 
     interface MealyLassoEmptinessOracle<I, O> extends LassoEmptinessOracle<MealyLasso<I, O>, I, Word<O>> {}

api/src/main/java/de/learnlib/api/oracle/LassoOracle.java

@@ -67,25 +67,15 @@ public interface LassoOracle<L extends Lasso<I, D>, I, D> {
      */
     boolean isCounterExample(Output<I, D> hypothesis, Iterable<? extends I> inputs, D output);
 
-    /**
-     * Returns whether a lasso that is ultimately periodic could serve as a counter example.
-     *
-     * @param isUltimatelyPeriodic
-     *          whether the lasso is ultimately periodic
-     *
-     * @return true when lasso that is ultimately periodic could serve as a counter example, false otherwise.
-     */
-    boolean isOmegaCounterExample(boolean isUltimatelyPeriodic);
-
     default @Nullable DefaultQuery<I, D> findCounterExample(L hypothesis, Collection<? extends I> inputs) {
         final Word<I> prefix = hypothesis.getPrefix();
         final Word<I> loop = hypothesis.getLoop();
         final int repeat = hypothesis.getUnfolds();
 
         final OmegaQuery<I, D> omegaQuery = processInput(prefix, loop, repeat);
 
-        if (isOmegaCounterExample(omegaQuery.isUltimatelyPeriodic())) {
-            @SuppressWarnings("assignment.type.incompatible") // when we are a counterexample, the output is valid
+        if (omegaQuery.isUltimatelyPeriodic()) {
+            @SuppressWarnings("nullness") // when we are a counterexample, the output is valid
             final DefaultQuery<I, D> ce = omegaQuery.asDefaultQuery();
 
             if (isCounterExample(hypothesis.getAutomaton(), ce.getInput(), ce.getOutput())) {

oracles/emptiness-oracles/src/main/java/de/learnlib/oracle/emptiness/LassoEmptinessOracleImpl.java

@@ -94,9 +94,4 @@ public boolean isCounterExample(Output<I, D> hypothesis, Iterable<? extends I> i
     public @Nullable DefaultQuery<I, D> findCounterExample(L hypothesis, Collection<? extends I> inputs) {
         return LassoOracle.super.findCounterExample(hypothesis, inputs);
     }
-
-    @Override
-    public boolean isOmegaCounterExample(boolean isUltimatelyPeriodic) {
-        return LassoEmptinessOracle.super.isOmegaCounterExample(isUltimatelyPeriodic);
-    }
 }