Package  Description 

de.uni_due.inf.ti.raven.algorithms 
Classes to run different algorithms.

Modifier and Type  Interface and Description 

interface 
CospanDecompositionAlgorithm
The algorithm interface for the computation of cospan decompositions of a given cospan.

interface 
EmptinessCheckAlgorithm
The algorithm interface for solving the emptiness problem.

interface 
GraphDecompositionAlgorithm
The algorithm interface for the computation of graph decompositions of a given graph.

interface 
InvariantCheckingAlgorithm
The algorithm interface for checking invariants.

interface 
LanguageEquivalenceAlgorithm
The algorithm interface for solving the language equivalence problem.

interface 
LanguageInclusionAlgorithm
The algorithm interface for solving the language inclusion problem.

interface 
MembershipAlgorithm
The algorithm interface for solving the membership problem.

interface 
SimulationAlgorithm
The algorithm interface for the computation of the simulation relation.

interface 
UniversalityAlgorithm
The algorithm interface for solving the universality problem.

Modifier and Type  Class and Description 

class 
AntichainInvariantChecking
This class implements the two antichain algorithms for checking invariants.

class 
AntichainLanguageInclusion
This class implements the two antichain algorithms deciding the language
inclusion problem for (finite) automata.

class 
AntichainUniversality
This class implements the two antichain algorithms deciding the universality
problem for (finite) automata.

class 
BackwardEmptinessCheck
Checks whether an automaton accepts the empty language.

class 
BackwardSimulationAlgorithm
This class implements the algorithm to compute the backward simulation relation.

class 
BisimulationUpToCongruenceInvariantChecking
This class implements the bisimulation up to congruence algorithm for both deciding the
language equivalence and the language inclusion problem for (finite) automata.

class 
BisimulationUpToCongruenceLanguageEquivalence
This class implements the bisimulation up to congruence algorithm for both deciding the
language equivalence and the language inclusion problem for (finite) automata.

class 
BisimulationUpToCongruenceLanguageInclusion
This class implements the bisimulation up to congruence algorithm for both deciding the
language equivalence and the language inclusion problem for (finite) automata.

class 
DefaultCospanDecompositionAlgorithm
This class implements an algorithm which is used to decompose a given
Cospan object into
an atomic cospan decomposition, represented by a CospanDecomposition object. 
class 
DefaultMembershipAlgorithm
This class implements the algorithm to solve the membership problem in the obvious way.

class 
ForwardEmptinessCheck
Checks whether an automaton accepts the empty language.

class 
ForwardSimulationAlgorithm
This class implements the algorithm to compute simulation relation in the obvious way.

class 
IdentityRelationAlgorithm
This class implements the algorithm to compute identity relation in the obvious way.

class 
LibTWAlgorithm
This class is the abstract basis for all decomposition algorithms from LibTW library.

class 
LibTWAllStartLexBFSAlgorithm
This class implements the AllStart LexBFS decomposition algorithm.

class 
LibTWGreedyDegreeAlgorithm
This class implements the Greedy Degree decomposition algorithm.

class 
LibTWGreedyFillInAlgorithm
This class implements the Greedy FillIn decomposition algorithm.

class 
LibTWLexBFSAlgorithm
This class implements the Greedy Degree decomposition algorithm.

class 
LibTWNGraphToGraphAlgorithm
Class to convert a LibTW graph (NGraph) into a (Raven) graph.

class 
SimulationAntichainInvariantChecking
This class implements the two antichain algorithms for checking invariants.

class 
SimulationAntichainLanguageInclusion
This class implements the two simulationbased antichain algorithms deciding
the language inclusion problem for (finite) automata.

class 
SimulationAntichainUniversality
This class implements the two simulationbased antichain algorithms deciding
the universality problem for (finite) automata.
