wip

learnlib/DumpRFSAEQOracle.java

+import de.learnlib.api.oracle.MembershipOracle;
+import de.learnlib.api.query.DefaultQuery;
+import de.learnlib.oracle.equivalence.RandomWordsEQOracle;
+import net.automatalib.automata.concepts.Output;
+import net.automatalib.automata.fsa.FiniteStateAcceptor;
+import net.automatalib.automata.fsa.NFA;
+
+import javax.annotation.Nullable;
+import java.util.Collection;
+import java.util.Random;
+
+public class DumpRFSAEQOracle<A extends FiniteStateAcceptor<?, I>, I, D> extends RandomWordsEQOracle<A, I, D> {
+    NFA<?, I> target;
+
+    public DumpRFSAEQOracle(NFA<?, I> target, MembershipOracle<I, D> mqOracle, int minLength, int maxLength, int maxTests) {
+        this(target, mqOracle, minLength, maxLength, maxTests, new Random(), 1);
+    }
+
+    public DumpRFSAEQOracle(NFA<?, I> target, MembershipOracle<I, D> mqOracle, int minLength, int maxLength, int maxTests, Random random) {
+        this(target, mqOracle, minLength, maxLength, maxTests, random, 1);
+    }
+
+    public DumpRFSAEQOracle(NFA<?, I> target, MembershipOracle<I,D> mqOracle, int minLength, int maxLength, int maxTests, Random random, int batchSize) {
+        super(mqOracle, minLength, maxLength, maxTests, random, batchSize);
+
+        this.target = target;
+    }
+
+    /**
+     * tries to short-hand the equivalence test, because minimal RFSA can be compared to some extent
+     */
+    @Nullable
+    @Override
+    public DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs) {
+        if (target.getStates().size() == hypothesis.getStates().size()) {
+            return null;
+        }
+
+        return super.findCounterExample(hypothesis, inputs);
+    }
+}

learnlib/GenRFSA.java

+import net.automatalib.automata.fsa.impl.compact.CompactNFA;
+import net.automatalib.util.automata.builders.FSABuilder;
+import net.automatalib.visualization.Visualization;
+
+public class GenRFSA<A extends CompactNFA<I>, S, I> {
+    public CompactNFA<I> reverse(A source){
+        FSABuilder<Integer, I, CompactNFA<I>> builder = new FSABuilder<>(new CompactNFA<>(source.getInputAlphabet(), source.getStates().size()));
+
+        for (int a : source.getStates()) {
+            if (source.isAccepting(a))
+                builder.withInitial(a);
+
+            for (I i: source.getInputAlphabet())
+                for (int c : source.getTransitions(a, i))
+                    builder.from(c).on(i).to(a);
+        }
+
+
+        builder.withAccepting(source.getInitialStates().toArray());
+        return builder.create();
+    }
+
+    public
+
+    public static void main(String[] args) {
+        RandomNFAGen c = new RandomNFAGen(10);
+        CompactNFA<Integer> nfa = c.get();
+        GenRFSA<CompactNFA<Integer>, ?, Integer> genRFSA = new GenRFSA<>();
+
+        Visualization.visualize(nfa);
+        Visualization.visualize(genRFSA.reverse(nfa));
+    }
+}

learnlib/RFSALearnAndCompare.java

 import de.learnlib.algorithms.nlstar.NLStarLearner;
 import de.learnlib.algorithms.nlstar.NLStarLearnerBuilder;
+import de.learnlib.filter.statistic.oracle.CounterOracle;
 import de.learnlib.oracle.equivalence.RandomWordsEQOracle;
 import de.learnlib.oracle.membership.SimulatorOracle;
 import de.learnlib.util.Experiment;
@@ -35,6 +36,10 @@ public class RFSALearnAndCompare<I> {
 
         mqOracle = new CounterOracle<>(sul, "membership queries learning");
         mqOracle2 = new CounterOracle<>(sul2, "membership queries learning");
+
+        CounterOracle<I, Boolean> mqOracle_2 = new CounterOracle<>(sul, "membership queries testing");
+        CounterOracle<I, Boolean> mqOracle2_2 = new CounterOracle<>(sul2, "membership queries testing");
+
         NLStarLearner<I> nlstar = new NLStarLearnerBuilder<I>().withAlphabet(target.getInputAlphabet()) // input alphabet
                         .withOracle(mqOracle) // membership oracle
                         .create();