net.automatalib.util.automata

Class Automata

java.lang.Object

net.automatalib.util.ts.TS

net.automatalib.util.automata.Automata

public class Automata
extends TS

Nested Class Summary

Nested classes/interfaces inherited from class net.automatalib.util.ts.TS

TS.TransRef<S,I>

Constructor Summary

Constructors

Constructor and Description
Automata()

Method Summary

Methods

Modifier and Type	Method and Description
static <S,I> Iterable<TS.TransRef<S,I>>	allDefinedTransitions(DeterministicAutomaton<S,I,?> automaton, Iterable<? extends I> inputs)
static <S,I> Iterator<TS.TransRef<S,I>>	allDefinedTransitionsIterator(DeterministicAutomaton<S,I,?> automaton, Iterable<? extends I> inputs)
static <S,I> Iterable<TS.TransRef<S,I>>	allUndefinedTransitions(DeterministicAutomaton<S,I,?> automaton, Iterable<? extends I> inputs)
static <S,I> Iterator<TS.TransRef<S,I>>	allUndefinedTransitionsIterator(DeterministicAutomaton<S,I,?> automaton, Iterable<? extends I> inputs)
static <S,I,T> Graph<S,TransitionEdge<I,T>>	asGraph(Automaton<S,I,T> automaton, Collection<? extends I> inputs)
static <S,I,T,SP,TP> UniversalGraph<S,TransitionEdge<I,T>,SP,TransitionEdge.Property<I,TP>>	asUniversalGraph(UniversalAutomaton<S,I,T,SP,TP> automaton, Collection<? extends I> inputs)
static <I> List<Word<I>>	characterizingSet(UniversalDeterministicAutomaton<?,I,?,?,?> automaton, Collection<? extends I> inputs) Computes a characterizing set, and returns it as a List.
static <I> void	characterizingSet(UniversalDeterministicAutomaton<?,I,?,?,?> automaton, Collection<? extends I> inputs, Collection<? super Word<I>> result) Computes a characterizing set for the given automaton.
static <I> void	cover(DeterministicAutomaton<?,I,?> automaton, Collection<? extends I> inputs, Collection<? super Word<I>> states, Collection<? super Word<I>> transitions)
static <I> Word<I>	findSeparatingWord(UniversalDeterministicAutomaton<?,I,?,?,?> reference, UniversalDeterministicAutomaton<?,I,?,?,?> other, Collection<? extends I> inputs) Finds a separating word for two automata.
static <S,I> Word<I>	findSeparatingWord(UniversalDeterministicAutomaton<S,I,?,?,?> automaton, S state1, S state2, Collection<? extends I> inputs) Finds a separating word for two states in an automaton.
static <S,I,T,SP,TP,A extends MutableDeterministic<S,I,T,SP,TP>> A	invasiveMinimize(A automaton, Collection<? extends I> inputs)
static <S,I,T,SP,TP,SO,TO,A extends MutableDeterministic<SO,? super I,TO,? super SP,? super TP>> A	minimize(UniversalDeterministicAutomaton<S,I,T,SP,TP> automaton, Collection<? extends I> inputs, A output)
static <S,I> List<Word<I>>	stateCharacterizingSet(UniversalDeterministicAutomaton<S,I,?,?,?> automaton, Collection<? extends I> inputs, S state) Computes a characterizing set for a single state, and returns it as a List.
static <S,I> void	stateCharacterizingSet(UniversalDeterministicAutomaton<S,I,?,?,?> automaton, Collection<? extends I> inputs, S state, Collection<? super Word<I>> result) Computes a characterizing set for a single state.
static <I> List<Word<I>>	stateCover(DeterministicAutomaton<?,I,?> automaton, Collection<? extends I> inputs)
static <I> List<Word<I>>	transitionCover(DeterministicAutomaton<?,I,?> automaton, Collection<? extends I> inputs)

Methods inherited from class net.automatalib.util.ts.TS

allDefinedTransitions, allDefinedTransitionsIterator, allTransitions, allUndefinedTransitions, allUndefinedTransitionsIterator, bfsOrder, definedTransitions, definedTransitionsIterator, stateProperties, transitionProperties, undefinedTransitions, undefinedTransitionsIterator

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Automata

public Automata()

Method Detail

asGraph

public static <S,I,T> Graph<S,TransitionEdge<I,T>> asGraph(Automaton<S,I,T> automaton,
                                           Collection<? extends I> inputs)

asUniversalGraph

public static <S,I,T,SP,TP> UniversalGraph<S,TransitionEdge<I,T>,SP,TransitionEdge.Property<I,TP>> asUniversalGraph(UniversalAutomaton<S,I,T,SP,TP> automaton,
                                                                                                    Collection<? extends I> inputs)

minimize

public static <S,I,T,SP,TP,SO,TO,A extends MutableDeterministic<SO,? super I,TO,? super SP,? super TP>> A minimize(UniversalDeterministicAutomaton<S,I,T,SP,TP> automaton,
                                                                                                   Collection<? extends I> inputs,
                                                                                                   A output)

invasiveMinimize

public static <S,I,T,SP,TP,A extends MutableDeterministic<S,I,T,SP,TP>> A invasiveMinimize(A automaton,
                                                                           Collection<? extends I> inputs)

findSeparatingWord

public static <I> Word<I> findSeparatingWord(UniversalDeterministicAutomaton<?,I,?,?,?> reference,
                             UniversalDeterministicAutomaton<?,I,?,?,?> other,
                             Collection<? extends I> inputs)

Finds a separating word for two automata. A separating word is a word that exposes a difference (differing state or transition properties, or a transition undefined in only one of the automata) between the two automata.

Parameters:

reference - the one automaton to consider

other - the other automaton to consider

inputs - the input symbols to consider

Returns:

a separating word, or null if no such word could be found.

findSeparatingWord

public static <S,I> Word<I> findSeparatingWord(UniversalDeterministicAutomaton<S,I,?,?,?> automaton,
                               S state1,
                               S state2,
                               Collection<? extends I> inputs)

Finds a separating word for two states in an automaton. A separating word is a word that exposes a difference (differing state or transition properties, or a transition undefined in only one of the paths) between the two states.

Parameters:

automaton - the automaton containing the states

state1 - the one state

state2 - the other state

inputs - the input symbols to consider

Returns:

a separating word, or null if no such word could be found

characterizingSet

public static <I> void characterizingSet(UniversalDeterministicAutomaton<?,I,?,?,?> automaton,
                         Collection<? extends I> inputs,
                         Collection<? super Word<I>> result)

Computes a characterizing set for the given automaton.

This is a convenience method acting as a shortcut to CharacterizingSets.findCharacterizingSet(UniversalDeterministicAutomaton, Collection, Collection).

Parameters:

automaton - the automaton for which to determine the characterizing set

inputs - the input symbols to consider

result - the collection in which to store the characterizing words

See Also:

CharacterizingSets

characterizingSet

public static <I> List<Word<I>> characterizingSet(UniversalDeterministicAutomaton<?,I,?,?,?> automaton,
                                  Collection<? extends I> inputs)

Computes a characterizing set, and returns it as a List.

Parameters:

automaton - the automaton for which to determine the characterizing set

inputs - the input symbols to consider

Returns:

a list containing the characterizing words

See Also:

CharacterizingSets

stateCharacterizingSet

public static <S,I> void stateCharacterizingSet(UniversalDeterministicAutomaton<S,I,?,?,?> automaton,
                                Collection<? extends I> inputs,
                                S state,
                                Collection<? super Word<I>> result)

Computes a characterizing set for a single state.

This is a convenience method acting as a shortcut to CharacterizingSets.findCharacterizingSet(UniversalDeterministicAutomaton, Collection, Object, Collection).

Parameters:

automaton - the automaton containing the state

inputs - the input symbols to consider

state - the state for which to determine a characterizing set

result - the collection in which to store the characterizing words

See Also:

CharacterizingSets

stateCharacterizingSet

public static <S,I> List<Word<I>> stateCharacterizingSet(UniversalDeterministicAutomaton<S,I,?,?,?> automaton,
                                         Collection<? extends I> inputs,
                                         S state)

Computes a characterizing set for a single state, and returns it as a List.

Parameters:

automaton - the automaton containing the state

inputs - the input symbols to consider

state - the state for which to determine a characterizing set

Returns:

a list containing the characterizing words

See Also:

CharacterizingSets

cover

public static <I> void cover(DeterministicAutomaton<?,I,?> automaton,
             Collection<? extends I> inputs,
             Collection<? super Word<I>> states,
             Collection<? super Word<I>> transitions)

stateCover

public static <I> List<Word<I>> stateCover(DeterministicAutomaton<?,I,?> automaton,
                           Collection<? extends I> inputs)

transitionCover

public static <I> List<Word<I>> transitionCover(DeterministicAutomaton<?,I,?> automaton,
                                Collection<? extends I> inputs)

allDefinedTransitionsIterator

public static <S,I> Iterator<TS.TransRef<S,I>> allDefinedTransitionsIterator(DeterministicAutomaton<S,I,?> automaton,
                                                             Iterable<? extends I> inputs)

allDefinedTransitions

public static <S,I> Iterable<TS.TransRef<S,I>> allDefinedTransitions(DeterministicAutomaton<S,I,?> automaton,
                                                     Iterable<? extends I> inputs)

allUndefinedTransitionsIterator

public static <S,I> Iterator<TS.TransRef<S,I>> allUndefinedTransitionsIterator(DeterministicAutomaton<S,I,?> automaton,
                                                               Iterable<? extends I> inputs)

allUndefinedTransitions

public static <S,I> Iterable<TS.TransRef<S,I>> allUndefinedTransitions(DeterministicAutomaton<S,I,?> automaton,
                                                       Iterable<? extends I> inputs)