3180
Comment: Added fysom

← Revision 17 as of 20140906 09:12:52 ⇥
5748
add tulip entry

Deletions are marked like this.  Additions are marked like this. 
Line 25:  Line 25: 
== Tulip (Temporal Logic Planning Toolbox) == [[http://tulipcontrol.sourceforge.net/tulip]] includes a subpackage called [[https://github.com/tulipcontrol/tulipcontrol/tree/master/tulip/transystransys]] that provides classes for (finite state) 1. Transition systems ([[https://en.wikipedia.org/wiki/Kripke_structure_%28model_checking%29Kripke Structures]], also known as generators of languages): * for closed systems * for open systems (that play against adversarial environments) The above support edge labeling, as well as state labeling (in that respect they are not pure Kripke structures and can be used to construct Labeledtransition systems, depending on the semantics assigned to the graph). 2. [[https://en.wikipedia.org/wiki/Automata_theoryAutomata]] (also known as acceptors): 1. Finiteword: * [[https://en.wikipedia.org/wiki/Deterministic_finite_automatonDeterministic Finite Automata]] (DFA) * [[https://en.wikipedia.org/wiki/Nondeterministic_finite_automatonNonDeterministic Finite Automata]] (NFA) 2. [[https://en.wikipedia.org/wiki/%CE%A9automatonInfiniteword]] (= ωautomata): * [[https://en.wikipedia.org/wiki/B%C3%BCchi_automatonBuchi Automata]] (BA) * Rabin Automata (RA) * Parity Automata 3. [[https://en.wikipedia.org/wiki/Finite_state_transducerMachines]] (also known as transducers): * [[https://en.wikipedia.org/wiki/Mealy_machineMealy machines]] * [[https://en.wikipedia.org/wiki/Moore_machineMoore machines]] The toolbox includes an extension of [[http://networkx.github.io/documentation/networkx1.9/reference/classes.multidigraph.html?highlight=multidigraph#networkx.MultiDiGraphnetworkx.MultiDiGraph]] to define typed labeling and also a subpackage for exporting the above classes to: * [[https://en.wikipedia.org/wiki/DOT_%28graph_description_language%29GraphViz dot]] (inluding: TikZ (LaTeX), ipython qtconsole inline plot support of graphviz output) * [[https://en.wikipedia.org/wiki/PromelaPromela]] (for transition systems only) * [[https://en.wikipedia.org/wiki/D3.jsd3]] The implemented algorithms include the synchronous product between transition systems and Buchi automata. Tulip itself is a package for synthesizing correctbyconstruction systems from a logic specification and a model expressed as a transition system, including  among other  functions for abstracting the continuous dynamics of systems governed by differential equations to finite state transition systems. 
Contents
Introduction
This is a summary of FSM implementations in Python right now. Licensing remains unclear.
For general information about finite state machines, see:
Wikipedia:Finite_state_machine  excellent!
Finite State Machine Editor
FSME is a tool where you can draw FSM diagrams, and then compile to a Python module (or C++ code.) It also makes an XML description of the FSM.
Requires QT for the editor. (Not the compiler, though, which probably reads XML.)
Tulip (Temporal Logic Planning Toolbox)
tulip includes a subpackage called transys that provides classes for (finite state)
Transition systems (Kripke Structures, also known as generators of languages):
 for closed systems
 for open systems (that play against adversarial environments)
Automata (also known as acceptors):
 Finiteword:
Infiniteword (= ωautomata):
Buchi Automata (BA)
 Rabin Automata (RA)
 Parity Automata
Machines (also known as transducers):
The toolbox includes an extension of networkx.MultiDiGraph to define typed labeling and also a subpackage for exporting the above classes to:
GraphViz dot (inluding: TikZ (LaTeX), ipython qtconsole inline plot support of graphviz output)
Promela (for transition systems only)
The implemented algorithms include the synchronous product between transition systems and Buchi automata.
Tulip itself is a package for synthesizing correctbyconstruction systems from a logic specification and a model expressed as a transition system, including  among other  functions for abstracting the continuous dynamics of systems governed by differential equations to finite state transition systems.
FSA  Finite State Automation in Python
FSA seems to be all about creating finite state machines, but I don't see a whole lot on how to use them.
Noah Spurrier's FSM
http://www.noah.org/python/FSM/
Noah's implementation is pure Python code. You init an FSM, register transitions, and then throw inputs at it. States and inputs must be hashable.
It's fairly similar to Skip's implementation (below).
fsmpy
This seems to be a Python wrapper around AT&T's FSM library. It's all oriented around "weighted" finite state machines, so I'm not so sure how suitable it is if you just want to use unweighted FSM.
Decoratorbased FSM
An example using decorators is in the Decorator Library on this site. The module simplifies implementation of FSM's based on UML 2.0 state diagrams. The FSM is implemented as a class, with methods of the class associated with transitions or with states. The design is not the best for constructing FSMs to parse text being somewhat slower than alternatives.
Skip Montanaro's FSM
Features transition actions.
pythonfsm FSM module with PyGraphViz support
An concise yet comprehensive implementation based on Wikipedia spec of Finite State Machines. The module can be used to build and further describe finite state automata with DOT graphs. It implements acceptors and transducers (Moore and Mealy machines) and provides an straightforward way to inject and execute state change actions for entry, exit, input and transition.
Licensed under the new BSD license.
http://code.google.com/p/pythonfsm/
fysom
A port of Jake Gordon's javascriptstatemachine. The module lets the user define callbacks for before/after events as well as callbacks on entering/leaving states. Events are exposed as object methods which when called, causes the appropriate state transition. The module also provides asynchronous callback functionality which allows delaying a state transition.