make most regular learners implement AccessSequenceTransformer

Author: mtf90

CHANGELOG.md

@@ -12,7 +12,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 * Added the L<sup>s</sup> active learning algorithm for Mealy machines (thanks to [Wolffhardt Schwabe](https://github.com/stateMachinist)).
 * Added an `EarlyExitEQOracle` which for a given `AdaptiveMembershipOracle` and `TestWordGenerator` stops the evaluation of (potentially long) Mealy-based equivalence tests as soon as a mismatch with the hypothesis is detected, potentially improving the symbol performance of the given equivalence oracle.
 * Both lambda learners (`LLambda{DFA,Mealy}` and `TTTLambda{DFA,Mealy}`) now support the `Resumable` interface.
-* The `LLambda{DFA,Mealy}` learners now implement the `OTLearner` interface to export their internal knowledge via an `ObservationTable`. 
+* The `LLambda{DFA,Mealy}` learners now implement the `OTLearner` interface to export their internal knowledge via an `ObservationTable`.
+* Most regular learner no implement `AccessSequenceTransformer` as a means to extract representatives of hypothesis states.
 
 ### Changed
 
@@ -22,6 +23,10 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 * The `generateTestWords` method of `AbstractTestWordEQOracle` now needs to be public.
 * The classes of `de.learnlib.testsupport.it.learner` have been split into the packages `de.learnlib.testsupport.it{,testcase,util,variant}` in the same module (`de.learnlib.testsupport:learnlib-learner-it-support`).
 
+### Removed
+
+* All *adapters* from the `learnlib-procedural` learner have been removed to due main learners implementing `AccessSequenceTransformer` now. Use the constructors of the main learners instead.
+
 ### Fixed
 
 * The `de.learnlib.algorithm.adt` module now correctly `exports` the `de.learnlib.algorithm.adt.config.model.*` packages.

algorithms/active/adt/src/main/java/de/learnlib/algorithm/adt/learner/ADTLearner.java

@@ -29,6 +29,7 @@
 import java.util.Queue;
 import java.util.Set;
 
+import de.learnlib.AccessSequenceTransformer;
 import de.learnlib.Resumable;
 import de.learnlib.algorithm.LearningAlgorithm;
 import de.learnlib.algorithm.adt.adt.ADT;
@@ -70,6 +71,9 @@
 
 /**
  * The main learning algorithm.
+ * <p>
+ * <b>Implementation note:</b> this learner uses the {@link AccessSequenceTransformer} interface to provide access to
+ * the representatives of the states of the current hypothesis model.
  *
  * @param <I>
  *         input symbol type
@@ -78,6 +82,7 @@
  */
 public class ADTLearner<I, O> implements LearningAlgorithm.MealyLearner<I, O>,
                                          PartialTransitionAnalyzer<ADTState<I, O>, I>,
+                                         AccessSequenceTransformer<I>,
                                          SupportsGrowingAlphabet<I>,
                                          Resumable<ADTLearnerState<ADTState<I, O>, I, O>> {
 
@@ -148,6 +153,7 @@ public void startLearning() {
 
     @Override
     public boolean refineHypothesis(DefaultQuery<I, Word<O>> ce) {
+        requireLearningProcessStarted();
 
         if (!MQUtil.isCounterexample(ce, this.hypothesis)) {
             return false;
@@ -409,6 +415,15 @@ public boolean isTransitionDefined(ADTState<I, O> state, I input) {
         return !transition.needsSifting();
     }
 
+    @Override
+    public Word<I> transformAccessSequence(Word<I> word) {
+        requireLearningProcessStarted();
+
+        final ADTState<I, O> state = this.hypothesis.getState(word);
+        assert state != null;
+        return state.getAccessSequence();
+    }
+
     @Override
     public void addAlphabetSymbol(I symbol) {
 
@@ -837,6 +852,12 @@ private List<ADTTransition<I, O>> getIncomingNonSpanningTreeTransitions(ADTState
         return result;
     }
 
+    private void requireLearningProcessStarted() {
+        if (hypothesis.getStates().isEmpty()) {
+            throw new IllegalStateException("Learning process has not been started");
+        }
+    }
+
     public ADT<ADTState<I, O>, I, O> getADT() {
         return adt;
     }

algorithms/active/adt/src/test/java/de/learnlib/algorithm/adt/learner/ADTASTTest.java

@@ -0,0 +1,79 @@
+/* Copyright (C) 2013-2026 TU Dortmund University
+ * This file is part of LearnLib <https://learnlib.de>.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package de.learnlib.algorithm.adt.learner;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+
+import de.learnlib.algorithm.adt.adt.ADT;
+import de.learnlib.algorithm.adt.adt.ADTLeafNode;
+import de.learnlib.algorithm.adt.adt.ADTNode;
+import de.learnlib.algorithm.adt.automaton.ADTState;
+import de.learnlib.algorithm.adt.util.ADTUtil;
+import de.learnlib.driver.simulator.MealySimulatorSUL;
+import de.learnlib.oracle.AdaptiveMembershipOracle;
+import de.learnlib.oracle.membership.SULAdaptiveOracle;
+import de.learnlib.testsupport.AbstractLearnerASTTest;
+import net.automatalib.alphabet.Alphabet;
+import net.automatalib.alphabet.impl.Alphabets;
+import net.automatalib.automaton.transducer.MealyMachine;
+import net.automatalib.util.automaton.random.RandomAutomata;
+import net.automatalib.word.Word;
+
+public class ADTASTTest
+        extends AbstractLearnerASTTest<ADTLearner<Integer, Character>, MealyMachine<?, Integer, ?, Character>, AdaptiveMembershipOracle<Integer, Character>, Integer, Word<Character>> {
+
+    @Override
+    protected Alphabet<Integer> getInitialAlphabet() {
+        return Alphabets.integers(1, 5);
+    }
+
+    @Override
+    protected MealyMachine<?, Integer, ?, Character> getSUL(Alphabet<Integer> alphabet) {
+        return RandomAutomata.randomMealy(new Random(42), 15, alphabet, Alphabets.characters('a', 'f'));
+    }
+
+    @Override
+    protected AdaptiveMembershipOracle<Integer, Character> getOracle(MealyMachine<?, Integer, ?, Character> target) {
+        return new SULAdaptiveOracle<>(new MealySimulatorSUL<>(target));
+    }
+
+    @Override
+    protected ADTLearner<Integer, Character> getLearner(AdaptiveMembershipOracle<Integer, Character> oracle,
+                                                        Alphabet<Integer> alphabet) {
+        return new ADTLearnerBuilder<Integer, Character>().withAlphabet(alphabet).withOracle(oracle).create();
+    }
+
+    @Override
+    protected Collection<Word<Integer>> getTrueRepresentatives() {
+        final ADT<ADTState<Integer, Character>, Integer, Character> adt = learner.getADT();
+        final Set<ADTNode<ADTState<Integer, Character>, Integer, Character>> leaves =
+                ADTUtil.collectLeaves(adt.getRoot());
+
+        final List<Word<Integer>> result = new ArrayList<>(leaves.size());
+
+        for (ADTNode<ADTState<Integer, Character>, Integer, Character> l : leaves) {
+            if (l instanceof ADTLeafNode<ADTState<Integer, Character>, Integer, Character> leaf) {
+                result.add(leaf.getState().getAccessSequence());
+            }
+        }
+
+        return result;
+    }
+}

algorithms/active/dhc/src/main/java/de/learnlib/algorithm/dhc/mealy/MealyDHC.java

@@ -48,6 +48,9 @@
 
 /**
  * The DHC learner.
+ * <p>
+ * <b>Implementation note:</b> this learner uses the {@link AccessSequenceTransformer} interface to provide access
+ * to the representatives of the states of the current hypothesis model.
  *
  * @param <I>
  *         input symbol type
@@ -291,7 +294,8 @@ public void resume(MealyDHCState<I, O> state) {
     @Override
     public Word<I> transformAccessSequence(Word<I> word) {
         checkInternalState();
-        Integer state = hypothesis.getSuccessor(hypothesis.getInitialState(), word);
+        Integer state = hypothesis.getState(word);
+        assert state != null;
         return assembleAccessSequence(accessSequences.get(state));
     }
 

…l/adapter/mealy/LLambdaAdapterMealy.java …algorithm/dhc/mealy/MealyDHCASTTest.javaalgorithms/active/procedural/src/main/java/de/learnlib/algorithm/procedural/adapter/mealy/LLambdaAdapterMealy.java renamed to algorithms/active/dhc/src/test/java/de/learnlib/algorithm/dhc/mealy/MealyDHCASTTest.java algorithms/active/procedural/src/main/java/de/learnlib/algorithm/procedural/adapter/mealy/LLambdaAdapterMealy.java renamed to algorithms/active/dhc/src/test/java/de/learnlib/algorithm/dhc/mealy/MealyDHCASTTest.java

@@ -13,24 +13,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package de.learnlib.algorithm.procedural.adapter.mealy;
+package de.learnlib.algorithm.dhc.mealy;
 
-import de.learnlib.algorithm.lambda.lstar.LLambdaMealy;
-import de.learnlib.oracle.MembershipOracle;
+import de.learnlib.oracle.MembershipOracle.MealyMembershipOracle;
+import de.learnlib.testsupport.AbstractLearnerASTMealyTest;
 import net.automatalib.alphabet.Alphabet;
-import net.automatalib.word.Word;
 
-/**
- * Adapter for using {@link LLambdaMealy} as a procedural learner.
- *
- * @param <I>
- *         input symbol type
- * @param <O>
- *         output symbol type
- */
-public class LLambdaAdapterMealy<I, O> extends LLambdaMealy<I, O> {
+public class MealyDHCASTTest extends AbstractLearnerASTMealyTest<MealyDHC<Character, Character>> {
 
-    public LLambdaAdapterMealy(Alphabet<I> alphabet, MembershipOracle<I, Word<O>> oracle) {
-        super(alphabet, oracle);
+    @Override
+    protected MealyDHC<Character, Character> getLearner(MealyMembershipOracle<Character, Character> oracle,
+                                                        Alphabet<Character> alphabet) {
+        return new MealyDHC<>(alphabet, oracle);
     }
+
 }

algorithms/active/kearns-vazirani/src/main/java/de/learnlib/algorithm/kv/dfa/KearnsVaziraniDFA.java

@@ -23,6 +23,7 @@
 import java.util.List;
 import java.util.function.BooleanSupplier;
 
+import de.learnlib.AccessSequenceTransformer;
 import de.learnlib.Resumable;
 import de.learnlib.acex.AbstractBaseCounterexample;
 import de.learnlib.acex.AcexAnalyzer;
@@ -48,12 +49,17 @@
 /**
  * The Kearns/Vazirani algorithm for learning DFA, as described in the book "An Introduction to Computational Learning
  * Theory" by Michael Kearns and Umesh Vazirani.
+ * <p>
+ * <b>Implementation note:</b> this learner uses the {@link AccessSequenceTransformer} interface to provide access to
+ * the representatives of the states of the current hypothesis model.
  *
  * @param <I>
  *         input symbol type
  */
-public class KearnsVaziraniDFA<I>
-        implements DFALearner<I>, SupportsGrowingAlphabet<I>, Resumable<KearnsVaziraniDFAState<I>> {
+public class KearnsVaziraniDFA<I> implements DFALearner<I>,
+                                             AccessSequenceTransformer<I>,
+                                             SupportsGrowingAlphabet<I>,
+                                             Resumable<KearnsVaziraniDFAState<I>> {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(KearnsVaziraniDFA.class);
 
@@ -65,6 +71,21 @@ public class KearnsVaziraniDFA<I>
     protected List<StateInfo<I, Boolean>> stateInfos = new ArrayList<>();
     private CompactDFA<I> hypothesis;
 
+    /**
+     * Constructor.
+     *
+     * @param alphabet
+     *         the learning alphabet
+     * @param oracle
+     *         the membership oracle
+     */
+    public KearnsVaziraniDFA(Alphabet<I> alphabet, MembershipOracle<I, Boolean> oracle) {
+        this(alphabet,
+             oracle,
+             BuilderDefaults.repeatedCounterexampleEvaluation(),
+             BuilderDefaults.counterexampleAnalyzer());
+    }
+
     /**
      * Constructor.
      *
@@ -97,9 +118,7 @@ public void startLearning() {
 
     @Override
     public boolean refineHypothesis(DefaultQuery<I, Boolean> ceQuery) {
-        if (hypothesis.size() == 0) {
-            throw new IllegalStateException("Not initialized");
-        }
+        requireLearningProcessStarted();
         Word<I> input = ceQuery.getInput();
         boolean output = ceQuery.getOutput();
         if (!refineHypothesisSingle(input, output)) {
@@ -115,9 +134,7 @@ public boolean refineHypothesis(DefaultQuery<I, Boolean> ceQuery) {
 
     @Override
     public DFA<?, I> getHypothesisModel() {
-        if (hypothesis.size() == 0) {
-            throw new IllegalStateException("Not started");
-        }
+        requireLearningProcessStarted();
         return hypothesis;
     }
 
@@ -298,6 +315,22 @@ private List<StateInfo<I, Boolean>> sift(List<AbstractWordBasedDTNode<I, Boolean
         return result;
     }
 
+    private void requireLearningProcessStarted() {
+        if (hypothesis.size() == 0) {
+            throw new IllegalStateException("Learning process has not been started");
+        }
+    }
+
+    @Override
+    public Word<I> transformAccessSequence(Word<I> word) {
+        requireLearningProcessStarted();
+
+        final Integer state = hypothesis.getState(word);
+        assert state != null;
+        final StateInfo<I, Boolean> stateInfo = stateInfos.get(state);
+        return stateInfo.accessSequence;
+    }
+
     @Override
     public void addAlphabetSymbol(I symbol) {