Added new learning examples, some TTT optimizations

Author: misberner

algorithms/ttt/src/main/java/de/learnlib/algorithms/ttt/base/BaseTTTLearner.java

@@ -27,6 +27,7 @@
 import java.util.Map;
 import java.util.Objects;
 import java.util.Queue;
+import java.util.Set;
 
 import javax.annotation.Nonnull;
 
@@ -39,6 +40,7 @@
 import net.automatalib.words.Word;
 
 import com.google.common.collect.AbstractIterator;
+import com.google.common.collect.Sets;
 
 import de.learnlib.algorithms.ttt.base.TTTHypothesis.TTTEdge;
 import de.learnlib.api.AccessSequenceTransformer;
@@ -71,6 +73,8 @@ public static class BuilderDefaults {
 	protected final DiscriminationTree<I,D> dtree;
 	// private final SuffixTrie<I> suffixTrie = new SuffixTrie<>();
 
+	private final Set<Word<I>> finalDiscriminators = Sets.newHashSet(Word.epsilon());
+	
 	private final Collection<WeakReference<TTTEventListener<I, D>>> eventListeners = new UnorderedCollection<>();
 
 	/**
@@ -145,10 +149,10 @@ public boolean refineHypothesis(DefaultQuery<I, D> ceQuery) {
 
 		DefaultQuery<I, D> currCe = ceQuery;
 
-		while(currCe != null) {
+		//while(currCe != null) {
 			while(refineHypothesisSingle(currCe));
-			currCe = checkHypothesisConsistency();
-		}
+//			currCe = checkHypothesisConsistency();
+//		}
 
 		return true;
 	}
@@ -425,6 +429,10 @@ private GlobalSplitter<I,D> findSplitterGlobal() {
 		Iterator<DTNode<I,D>> blocksIt = blockList.iterator();
 		while(blocksIt.hasNext()) {
 			DTNode<I,D> blockRoot = blocksIt.next();
+			if (finalDiscriminators.contains(blockRoot.getDiscriminator().subWord(1))) {
+				declareFinal(blockRoot);
+				continue;
+			}
 			Splitter<I,D> splitter = findSplitter(blockRoot);
 			if(splitter != null) {
 				if(bestSplitter == null || splitter.discriminator.length()
@@ -521,38 +529,38 @@ private Splitter<I,D> findSplitter(DTNode<I,D> blockRoot) {
 		return new Splitter<>(state1, state2, bestI, bestLCA);
 	}
 
-	/**
-	 * Checks whether the hypothesis is consistent with the discrimination tree.
-	 * If an inconsistency is discovered, it is returned in the form of a counterexample.
-	 * 
-	 * @return a counterexample uncovering an inconsistency, or {@code null}
-	 * if the hypothesis is consistent with the discrimination tree
-	 */
-	// TODO can be removed
-	private DefaultQuery<I, D> checkHypothesisConsistency() {
-		for(DTNode<I,D> leaf : dtree.getRoot().subtreeLeaves()) {
-			TTTState<I,D> state = leaf.state;
-			if(state == null) {
-				continue;
-			}
-			
-			DTNode<I,D> curr = state.dtLeaf;
-			DTNode<I,D> next = curr.getParent();
-			
-			while(next != null) {
-				Word<I> discr = next.getDiscriminator();
-				D expected = curr.getParentEdgeLabel();
-				
-				if(!Objects.equals(computeHypothesisOutput(state, discr), expected)) {
-					return new DefaultQuery<>(state.getAccessSequence(), discr, expected);
-				}
-				curr = next;
-				next = curr.getParent();
-			}
-		}
-		
-		return null;
-	}
+//	/**
+//	 * Checks whether the hypothesis is consistent with the discrimination tree.
+//	 * If an inconsistency is discovered, it is returned in the form of a counterexample.
+//	 * 
+//	 * @return a counterexample uncovering an inconsistency, or {@code null}
+//	 * if the hypothesis is consistent with the discrimination tree
+//	 */
+//	// TODO can be removed
+//	private DefaultQuery<I, D> checkHypothesisConsistency() {
+//		for(DTNode<I,D> leaf : dtree.getRoot().subtreeLeaves()) {
+//			TTTState<I,D> state = leaf.state;
+//			if(state == null) {
+//				continue;
+//			}
+//			
+//			DTNode<I,D> curr = state.dtLeaf;
+//			DTNode<I,D> next = curr.getParent();
+//			
+//			while(next != null) {
+//				Word<I> discr = next.getDiscriminator();
+//				D expected = curr.getParentEdgeLabel();
+//				
+//				if(!Objects.equals(computeHypothesisOutput(state, discr), expected)) {
+//					return new DefaultQuery<>(state.getAccessSequence(), discr, expected);
+//				}
+//				curr = next;
+//				next = curr.getParent();
+//			}
+//		}
+//		
+//		return null;
+//	}
 
 	/**
 	 * Creates a state in the hypothesis. This method cannot be used for the initial
@@ -581,8 +589,7 @@ protected TTTState<I,D> getTarget(TTTTransition<I,D> trans) {
 		if(trans.isTree()) {
 			return trans.getTreeTarget();
 		}
-		DTNode<I,D> dtTarget = updateDTTarget(trans);
-		return dtTarget.state;
+		return updateTarget(trans);
 	}
 
 	/**
@@ -628,15 +635,15 @@ private void finalizeDiscriminator(DTNode<I,D> blockRoot, Splitter<I,D> splitter
 		notifyPreFinalizeDiscriminator(blockRoot, splitter);
 
 		Word<I> finalDiscriminator = prepareSplit(blockRoot, splitter);
-		
 		Map<D,DTNode<I,D>> repChildren = createMap();
-		
+			
 		for (D label : blockRoot.splitData.getLabels()) {
 			repChildren.put(label, extractSubtree(blockRoot, label));
 		}
 		blockRoot.replaceChildren(repChildren);
-
+	
 		blockRoot.setDiscriminator(finalDiscriminator);
+
 		declareFinal(blockRoot);
 
 		notifyPostFinalizeDiscriminator(blockRoot, splitter);
@@ -647,6 +654,7 @@ protected void declareFinal(DTNode<I,D> blockRoot) {
 		blockRoot.splitData = null;
 
 		blockRoot.removeFromBlockList();
+		finalDiscriminators.add(blockRoot.getDiscriminator());
 
 		for (DTNode<I,D> subtree : blockRoot.getChildren()) {
 			assert subtree.splitData == null;
@@ -668,13 +676,14 @@ protected void declareFinal(DTNode<I,D> blockRoot) {
 	 * @return the discriminator to use for splitting
 	 */
 	private Word<I> prepareSplit(DTNode<I,D> node, Splitter<I,D> splitter) {
+		int symbolIdx = splitter.symbolIdx;
+		I symbol = alphabet.getSymbol(symbolIdx);
+		Word<I> discriminator = splitter.discriminator.prepend(symbol);
+		
 		Deque<DTNode<I,D>> dfsStack = new ArrayDeque<>();
 
 		DTNode<I,D> succSeparator = splitter.succSeparator;
-		int symbolIdx = splitter.symbolIdx;
-		I symbol = alphabet.getSymbol(symbolIdx);
 
-		Word<I> discriminator = splitter.discriminator.prepend(symbol);
 
 		dfsStack.push(node);
 		assert node.splitData == null;
@@ -1027,13 +1036,7 @@ private void closeTransition(TTTTransition<I,D> trans) {
 			return;
 		}
 
-		DTNode<I,D> dtTarget = updateDTTarget(trans);
-
-		if(dtTarget.state == null) {
-			TTTState<I,D> state = createState(trans);
-			link(dtTarget, state);
-			initializeState(state);
-		}
+		updateTarget(trans);
 	}
 
 	/**
@@ -1047,6 +1050,19 @@ private DTNode<I,D> updateDTTarget(TTTTransition<I,D> transition) {
 		return updateDTTarget(transition, true);
 	}
 
+	private TTTState<I, D> updateTarget(TTTTransition<I, D> trans) {
+		DTNode<I,D> node = updateDTTarget(trans);
+		
+		TTTState<I,D> state = node.state;
+		if (state == null) {
+			state = createState(trans);
+			link(node, state);
+			initializeState(state);
+		}
+		
+		return state;
+	}
+	
 	/**
 	 * Updates the transition to point to either a leaf in the discrimination tree,
 	 * or---if the {@code hard} parameter is set to {@code false}---to a block

core/src/main/java/de/learnlib/mealy/MealyLearnerWrapper.java

@@ -25,7 +25,7 @@
 import de.learnlib.oracles.DefaultQuery;
 
 @ParametersAreNonnullByDefault
-final class MealyLearnerWrapper<M extends MealyMachine<?, I, ?, O>, I, O> implements LearningAlgorithm<M, I, Word<O>> {
+final class MealyLearnerWrapper<M extends MealyMachine<?, I, ?, O>, I, O> implements LearningAlgorithm.MealyLearner<I, O> {
 
 	private final LearningAlgorithm<M, I, O> learner;
 

core/src/main/java/de/learnlib/mealy/MealyUtil.java

@@ -120,7 +120,7 @@ public static <I,O> DefaultQuery<I,O> reduceCounterExample(
 
 	@Nonnull
 	public static <M extends MealyMachine<?,I,?,O>,I,O>
-	LearningAlgorithm<M,I,Word<O>> wrapSymbolLearner(LearningAlgorithm<M,I,O> learner) {
+	LearningAlgorithm.MealyLearner<I,O> wrapSymbolLearner(LearningAlgorithm<M,I,O> learner) {
 		return new MealyLearnerWrapper<>(learner);
 	}
 

test-support/learning-examples/pom.xml

@@ -49,6 +49,10 @@ http://www.gnu.de/documents/lgpl.en.html.
 			<groupId>net.automatalib</groupId>
 			<artifactId>automata-util</artifactId>
 		</dependency>
+		<dependency>
+			<groupId>net.automatalib</groupId>
+			<artifactId>automata-serialization-learnlibv2</artifactId>
+		</dependency>
 	</dependencies>
 
 </project>

test-support/learning-examples/src/main/java/de/learnlib/examples/dfa/DFABenchmarks.java

@@ -0,0 +1,49 @@
+package de.learnlib.examples.dfa;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+import net.automatalib.automata.fsa.impl.compact.CompactDFA;
+import net.automatalib.serialization.learnlibv2.LearnLibV2Serialization;
+import de.learnlib.examples.DefaultLearningExample.DefaultDFALearningExample;
+import de.learnlib.examples.LearningExample.DFALearningExample;
+
+public class DFABenchmarks {
+	
+	public static DFALearningExample<Integer> loadLearnLibV2Benchmark(String name) {
+		String resourceName = "/automata/learnlibv2/" + name + ".dfa";
+		DFABenchmarks.class.getResource(resourceName);
+		if (DFABenchmarks.class.getResource(resourceName) == null) {
+			resourceName += ".gz"; // look for GZip compressed resource
+			if (DFABenchmarks.class.getResource(resourceName) == null) {
+				return null;
+			}
+		}
+		
+		try (InputStream is = DFABenchmarks.class.getResourceAsStream(resourceName)) {
+			CompactDFA<Integer> dfa = LearnLibV2Serialization.getInstance().readGenericDFA(is);
+			return new DefaultDFALearningExample<>(dfa);
+		}
+		catch (IOException ex) {
+			ex.printStackTrace();
+			return null;
+		}
+	}
+	
+	
+	public static DFALearningExample<Integer> loadPots2() {
+		return loadLearnLibV2Benchmark("pots2");
+	}
+	
+	public static DFALearningExample<Integer> loadPots3() {
+		return loadLearnLibV2Benchmark("pots3");
+	}
+	
+	public static DFALearningExample<Integer> loadPeterson2() {
+		return loadLearnLibV2Benchmark("peterson2");
+	}
+	
+	public static DFALearningExample<Integer> loadPeterson3() {
+		return loadLearnLibV2Benchmark("peterson3");
+	}
+}

test-support/learning-examples/src/main/java/de/learnlib/examples/dfa/ExampleRandomDFA.java

@@ -0,0 +1,19 @@
+package de.learnlib.examples.dfa;
+
+import java.util.Random;
+
+import net.automatalib.util.automata.random.RandomAutomata;
+import net.automatalib.words.impl.Alphabets;
+import de.learnlib.examples.DefaultLearningExample.DefaultDFALearningExample;
+
+public class ExampleRandomDFA extends DefaultDFALearningExample<Integer> {
+
+	public ExampleRandomDFA(Random rand, int numInputs, int size) {
+		super(RandomAutomata.randomDFA(rand, size, Alphabets.integers(0, numInputs - 1)));
+	}
+	
+	public ExampleRandomDFA(int numInputs, int size) {
+		this(new Random(), numInputs, size);
+	}
+
+}

test-support/learning-examples/src/main/java/de/learnlib/examples/mealy/ExampleRandomMealy.java

@@ -38,5 +38,10 @@ ExampleRandomMealy<I,O> createExample(Random random, Alphabet<I> alphabet, int s
 	public ExampleRandomMealy(Random random, Alphabet<I> alphabet, int size, O... outputs) {
 		super(RandomAutomata.randomDeterministic(random, size, alphabet, null, Arrays.asList(outputs), new CompactMealy<I,O>(alphabet)));
 	}
+	
+	@SafeVarargs
+	public ExampleRandomMealy(Alphabet<I> alphabet, int size, O... outputs) {
+		this(new Random(), alphabet, size, outputs);
+	}
 
 }