equivalence-oracles: add EarlyExitEQOracle

Author: mtf90

CHANGELOG.md

@@ -6,9 +6,14 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 [Full changelog](https://github.com/LearnLib/learnlib/compare/learnlib-0.18.0...HEAD)
 
+### Added
+
+* 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.
+
 ### Changed
 
 * LearnLib now requires Java 11 at runtime.
+* The `generateTestWords` method of `AbstractTestWordEQOracle` now needs to be public.
 
 ### Fixed
 

api/src/main/java/de/learnlib/TestWordGenerator.java

@@ -0,0 +1,47 @@
+/* Copyright (C) 2013-2025 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;
+
+import java.util.Collection;
+import java.util.stream.Stream;
+
+import de.learnlib.oracle.EquivalenceOracle;
+import net.automatalib.word.Word;
+
+/**
+ * A markup interface for generators of testing sequences (such as {@link EquivalenceOracle} implementations).
+ *
+ * @param <A>
+ *         automaton type
+ * @param <I>
+ *         input symbol type
+ */
+public interface TestWordGenerator<A, I> {
+
+    /**
+     * Generate the stream of words that should be evaluated for the given hypothesis.
+     *
+     * @param hypothesis
+     *         the current hypothesis
+     * @param inputs
+     *         the collection of inputs to consider
+     *
+     * @return the stream of test words used for (equivalence) testing
+     *
+     * @see EquivalenceOracle#findCounterExample(Object, Collection)
+     */
+    Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs);
+}

oracles/equivalence-oracles/pom.xml

@@ -76,6 +76,11 @@ limitations under the License.
         </dependency>
 
         <!-- test -->
+        <dependency>
+            <groupId>de.learnlib</groupId>
+            <artifactId>learnlib-drivers-simulator</artifactId>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>de.learnlib</groupId>
             <artifactId>learnlib-membership-oracles</artifactId>

oracles/equivalence-oracles/src/main/java/de/learnlib/oracle/equivalence/AbstractTestWordEQOracle.java

@@ -20,6 +20,7 @@
 import java.util.Objects;
 import java.util.stream.Stream;
 
+import de.learnlib.TestWordGenerator;
 import de.learnlib.logging.Category;
 import de.learnlib.oracle.EquivalenceOracle;
 import de.learnlib.oracle.MembershipOracle;
@@ -33,7 +34,7 @@
 
 /**
  * An abstract equivalence oracle that takes care of query batching and hypothesis checking and allows extending classes
- * to solely focus on test word generation by implementing {@link #generateTestWords(Output, Collection)}.
+ * to solely focus on test word generation by implementing {@link #generateTestWords(Object, Collection)}}.
  * <p>
  * Being {@link Stream stream}-based, this oracle encourages the lazy computation of counterexamples, so that all
  * counterexamples do not have to be computed upfront, but only until the first valid counterexample is found.
@@ -45,7 +46,8 @@
  * @param <D>
  *         output (domain) type
  */
-public abstract class AbstractTestWordEQOracle<A extends Output<I, D>, I, D> implements EquivalenceOracle<A, I, D> {
+public abstract class AbstractTestWordEQOracle<A extends Output<I, D>, I, D>
+        implements EquivalenceOracle<A, I, D>, TestWordGenerator<A, I> {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(AbstractTestWordEQOracle.class);
 
@@ -82,20 +84,6 @@ public AbstractTestWordEQOracle(MembershipOracle<I, D> membershipOracle, int bat
         return ceStream.findFirst().orElse(null);
     }
 
-    /**
-     * Generate the stream of test words that should be used for the current equivalence check cycle.
-     *
-     * @param hypothesis
-     *         the current hypothesis of the learning algorithm
-     * @param inputs
-     *         the collection of inputs to consider
-     *
-     * @return the stream of test words used for equivalence testing
-     *
-     * @see EquivalenceOracle#findCounterExample(Object, Collection)
-     */
-    protected abstract Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs);
-
     private Stream<DefaultQuery<I, D>> answerQueries(Stream<DefaultQuery<I, D>> stream) {
         if (isBatched()) {
             return IteratorUtil.stream(IteratorUtil.batch(stream.iterator(), this.batchSize))

oracles/equivalence-oracles/src/main/java/de/learnlib/oracle/equivalence/CompleteExplorationEQOracle.java

@@ -126,7 +126,7 @@ public CompleteExplorationEQOracle(MembershipOracle<I, D> sulOracle, int minDept
     }
 
     @Override
-    protected Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {
+    public Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {
         return IterableUtil.stream(IterableUtil.allTuples(inputs, minDepth, maxDepth)).map(Word::fromList);
     }
 }

oracles/equivalence-oracles/src/main/java/de/learnlib/oracle/equivalence/IncrementalWMethodEQOracle.java

@@ -102,7 +102,7 @@ public void setMaxDepth(int maxDepth) {
     }
 
     @Override
-    protected Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {
+    public Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {
         // FIXME: warn about inputs being ignored?
         incrementalWMethodIt.update(hypothesis);
 

oracles/equivalence-oracles/src/main/java/de/learnlib/oracle/equivalence/RandomWMethodEQOracle.java

@@ -185,7 +185,7 @@ public RandomWMethodEQOracle(MembershipOracle<I, D> sulOracle,
     }
 
     @Override
-    protected Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {
+    public Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {
         UniversalDeterministicAutomaton<?, I, ?, ?, ?> aut = hypothesis;
         return doGenerateTestWords(aut, inputs);
     }

oracles/equivalence-oracles/src/main/java/de/learnlib/oracle/equivalence/RandomWordsEQOracle.java

@@ -103,7 +103,7 @@ public RandomWordsEQOracle(MembershipOracle<I, D> mqOracle,
     }
 
     @Override
-    protected Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {
+    public Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {
 
         final List<? extends I> symbolList = CollectionUtil.randomAccessList(inputs);
 

oracles/equivalence-oracles/src/main/java/de/learnlib/oracle/equivalence/RandomWpMethodEQOracle.java

@@ -186,7 +186,7 @@ public RandomWpMethodEQOracle(MembershipOracle<I, D> sulOracle,
     }
 
     @Override
-    protected Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {
+    public Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {
         UniversalDeterministicAutomaton<?, I, ?, ?, ?> aut = hypothesis;
         return doGenerateTestWords(aut, inputs);
     }

oracles/equivalence-oracles/src/main/java/de/learnlib/oracle/equivalence/WMethodEQOracle.java

@@ -151,7 +151,7 @@ public WMethodEQOracle(MembershipOracle<I, D> sulOracle, int lookahead, int expe
     }
 
     @Override
-    protected Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {
+    public Stream<Word<I>> generateTestWords(A hypothesis, Collection<? extends I> inputs) {
         return IteratorUtil.stream(new WMethodTestsIterator<>(hypothesis,
                                                               inputs,
                                                               Math.max(lookahead, expectedSize - hypothesis.size())));