lsharp: remove side-effects of getHypothesisModel()

closes #145

Author: mtf90

algorithms/active/lsharp/pom.xml

@@ -70,6 +70,21 @@ 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-equivalence-oracles</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>de.learnlib</groupId>
+            <artifactId>learnlib-membership-oracles</artifactId>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>de.learnlib.testsupport</groupId>
             <artifactId>learnlib-learner-it-support</artifactId>
@@ -84,11 +99,28 @@ limitations under the License.
             <artifactId>automata-serialization-dot</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>net.automatalib</groupId>
+            <artifactId>automata-util</artifactId>
+            <scope>test</scope>
+        </dependency>
 
         <dependency>
             <groupId>org.testng</groupId>
             <artifactId>testng</artifactId>
         </dependency>
-
     </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <configuration>
+                    <!-- append to existing argLine to nicely work together with jacoco plugin -->
+                    <argLine>@{argLine} --add-reads=de.learnlib.algorithm.lsharp=net.automatalib.util</argLine>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
 </project>

algorithms/active/lsharp/src/main/java/de/learnlib/algorithm/lsharp/LSharpMealy.java

@@ -229,6 +229,20 @@ public void updateFrontierAndBasis() {
         }
     }
 
+    public CompactMealy<I, O> buildHypothesis() {
+        while (true) {
+            this.makeObsTreeAdequate();
+            CompactMealy<I, O> hyp = this.constructHypothesis();
+
+            DefaultQuery<I, Word<O>> ce = this.checkConsistency(hyp);
+            if (ce != null) {
+                this.processCex(ce, hyp);
+            } else {
+                return hyp;
+            }
+        }
+    }
+
     public CompactMealy<I, O> constructHypothesis() {
 
         CompactMealy<I, O> result = new CompactMealy<>(inputAlphabet, basis.size());
@@ -319,26 +333,19 @@ public void checkFrontierConsistency() {
     @Override
     public void startLearning() {
         this.initObsTree(null);
+        buildHypothesis();
     }
 
     @Override
     public boolean refineHypothesis(DefaultQuery<I, Word<O>> ceQuery) {
-        return processCex(ceQuery, getHypothesisModel());
+        boolean result = processCex(ceQuery, constructHypothesis());
+        buildHypothesis();
+        return result;
     }
 
     @Override
-    public CompactMealy<I, O> getHypothesisModel() {
-        while (true) {
-            this.makeObsTreeAdequate();
-            CompactMealy<I, O> hyp = this.constructHypothesis();
-
-            DefaultQuery<I, Word<O>> ce = this.checkConsistency(hyp);
-            if (ce != null) {
-                this.processCex(ce, hyp);
-            } else {
-                return hyp;
-            }
-        }
+    public MealyMachine<?, I, ?, O> getHypothesisModel() {
+        return constructHypothesis();
     }
 
     static final class BuilderDefaults {

algorithms/active/lsharp/src/test/java/de/learnlib/algorithm/lsharp/LSharpMealyTest.java

@@ -0,0 +1,91 @@
+/* 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.algorithm.lsharp;
+
+import java.util.Collection;
+import java.util.Random;
+
+import de.learnlib.driver.simulator.MealySimulatorSUL;
+import de.learnlib.oracle.AdaptiveMembershipOracle;
+import de.learnlib.oracle.equivalence.MealySimulatorEQOracle;
+import de.learnlib.oracle.membership.SULAdaptiveOracle;
+import de.learnlib.query.AdaptiveQuery;
+import de.learnlib.query.DefaultQuery;
+import net.automatalib.alphabet.Alphabet;
+import net.automatalib.alphabet.impl.Alphabets;
+import net.automatalib.automaton.transducer.MealyMachine;
+import net.automatalib.automaton.transducer.impl.CompactMealy;
+import net.automatalib.util.automaton.Automata;
+import net.automatalib.util.automaton.random.RandomAutomata;
+import net.automatalib.word.Word;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+public class LSharpMealyTest {
+
+    /**
+     * Checks that {@link LSharpMealy#getHypothesisModel()} is free of side-effects. For details, see <a
+     * href="https://github.com/LearnLib/learnlib/issues/145">issue 145</a>.
+     */
+    @Test
+    public void testIssue145() {
+        Alphabet<Integer> alphabet = Alphabets.integers(0, 1);
+        CompactMealy<Integer, Character> mealy =
+                RandomAutomata.randomMealy(new Random(42), 20, alphabet, Alphabets.characters('a', 'c'));
+
+        ValidatingOracle<Integer, Character> mqo =
+                new ValidatingOracle<>(new SULAdaptiveOracle<>(new MealySimulatorSUL<>(mealy)));
+        MealySimulatorEQOracle<Integer, Character> eqo = new MealySimulatorEQOracle<>(mealy);
+        LSharpMealy<Integer, Character> learner = new LSharpMealyBuilder<Integer, Character>().withAlphabet(alphabet)
+                                                                                              .withOracle(mqo)
+                                                                                              .withRandom(new Random(42))
+                                                                                              .create();
+
+        mqo.mutable = true;
+        learner.startLearning();
+        mqo.mutable = false;
+        MealyMachine<?, Integer, ?, Character> hyp = learner.getHypothesisModel();
+        DefaultQuery<Integer, Word<Character>> cex;
+
+        while ((cex = eqo.findCounterExample(hyp, alphabet)) != null) {
+            mqo.mutable = true;
+            learner.refineHypothesis(cex);
+            mqo.mutable = false;
+            hyp = learner.getHypothesisModel();
+        }
+
+        Assert.assertTrue(Automata.testEquivalence(mealy, learner.getHypothesisModel(), alphabet));
+    }
+
+    private static final class ValidatingOracle<I, O> implements AdaptiveMembershipOracle<I, O> {
+
+        private final AdaptiveMembershipOracle<I, O> delegate;
+        private boolean mutable;
+
+        ValidatingOracle(AdaptiveMembershipOracle<I, O> delegate) {
+            this.delegate = delegate;
+            this.mutable = false;
+        }
+
+        @Override
+        public void processQueries(Collection<? extends AdaptiveQuery<I, O>> adaptiveQueries) {
+            Assert.assertTrue(mutable);
+            this.delegate.processQueries(adaptiveQueries);
+
+        }
+    }
+
+}