Welcome to Vcsn

Welcome to this Vcsn tutorial. Vcsn is a platform (C++ libraries with various interfaces, a Python binding, and some specific features for IPython) for weighted automata and rational expressions.

This tutorial tries to guide you through the Python binding, and more specifically the IPython interface, of Vcsn. If you are not a Python programmer, rest assured that you don't need to know much, and if you are a Python programmer, rest assured that its conventions have been respected, and you will be able to take the full benefit from both Vcsn and Python.

  • Welcome to Vcsn - This page
  • Contexts - The typing system for automata, expressions, etc.
  • Editing Automata - How to define or edit automata
  • Algorithms - Available operations on automata, expressions, etc.
  • References - Publications on the algorithms and constructs used in Vcsn
  • Hacking - Random notes, badly written, obsolete, meant for Vcsn developers

Quick Start

Vcsn offers several interfaces:

  • fast efficient C++ templated library dubbed static
  • a dynamic and flexible C++ interface dubbed dyn on top of static
  • a Python interface on top of dyn
  • an IPython interface built on top of the Python API (which is used to generate this very document)
  • and also a (somewhat obsolete) shell interface named TAF-Kit.

This documentation shows how to use the IPython interactive environment. Provided that Vcsn was properly deployed on your platform, to launch it run the following command from your shell:

vcsn notebook

A web browser should open on a list of files. Click on the "New Notebook" button, which should open a new sheet. The remainder of this documentation is about such sheets.

First, import Vcsn into Python, and define the "context" in which you want to work. Do not worry about the (ugly!) syntax, just see where the alphabet (the set of letters, $\{a, b, c\}$) is defined. The last line (ctx) is here so that IPython displays what this variable contains.

In [1]: 
import vcsn
ctx = vcsn.context("lal_char(abc), b")
ctx
Out[1]:
$\{a, b, c\}\rightarrow\mathbb{B}$

This object, the context, defines the types of the various entities. To build a rational expression on this alphabet, use ctx.ratexp as follows:

In [2]: 
r1 = ctx.ratexp("ab*")
r1
Out[2]:
$a \, {b}^{*}$

The syntax for rational expressions is as follows (with increasing precedence):

  • \z denotes the empty language
  • \e denotes the language of the empty word
  • a denotes the language of the word a
  • e+f denotes the union of the languages of e and f (note the use of +, | is not accepted)
  • ef denotes the concatenation of the languages of e and f
  • e* denotes the Kleene closure of the language of e

So for instance r1 denotes the words starting with a single a followed by any number of bs.

Rational expressions are objects that feature methods. One such method is shortest(number) that lists the number first (in shortlex order) words of the language defined by the rational expresion:

In [3]: 
r1.shortest(10)
Out[3]:
$a \oplus \mathit{ab} \oplus \mathit{abb} \oplus \mathit{abbb} \oplus \mathit{abbbb} \oplus \mathit{abbbbb} \oplus \mathit{abbbbbb} \oplus \mathit{abbbbbbb} \oplus \mathit{abbbbbbbb} \oplus \mathit{abbbbbbbbb}$

You may compose rational expressions using Python operators such as + for sum, * for multiplication (concatenation):

In [4]: 
r1 + r1 * r1
Out[4]:
$a \, {b}^{*} + a \, {b}^{*} \, a \, {b}^{*}$

Vcsn features different means to build an automaton from a rational expression. The ratexp.standard() method builds the "standard autamaton", also known as the "position automaton", or the "Glushkov automaton":

In [5]: 
r1.standard()
Out[5]:
%3 I0 0 0 I0->0 F1 F3 1 1 0->1 a 1->F1 3 3 1->3 b 3->F3 3->3 b

When it comes to displaying automata as graphs, there are several "traditions". In Vcsns, initial states are denoted by an entering arrow, and final (or "accepting") states are denoted by an exiting arrow. This automaton has one initial state, and two final states.

The ratexp.derived_term() method builds the "derived-term automaton", aka, the Antimirov automaton.

In [6]: 
a1 = r1.derived_term()
a1
Out[6]:
%3 I0 0 ab* I0->0 F1 1 b* 0->1 a 1->F1 1->1 b

Python operators that are accepted by rational expressions are also accepted by automata, with matching semantics.

In [7]: 
a2 = (r1 + r1*r1).derived_term()
a2
Out[7]:
%3 I0 0 ab*+ab*ab* I0->0 F1 1 b* 0->1 a 2 b*ab* 0->2 a 1->F1 1->1 b 2->1 a 2->2 b
In [8]: 
a3 = a1 + a1 * a1
a3
Out[8]:
%3 I0 0 0 I0->0 F1 F3 1 1 0->1 a 2 2 0->2 a 1->F1 1->1 b 2->2 b 3 3 2->3 a 3->F3 3->3 b

Well, those two automata are not equal (or more rigorously "isomorphic"), but they are equivalent:

In [9]: 
a2.is_equivalent(a3)
Out[9]:
True

All the classical algorithms about automata are implemented:

In [10]: 
a3
Out[10]:
%3 I0 0 0 I0->0 F1 F3 1 1 0->1 a 2 2 0->2 a 1->F1 1->1 b 2->2 b 3 3 2->3 a 3->F3 3->3 b
In [11]: 
a3.determinize()
Out[11]:
%3 I0 0 0 I0->0 F1 F2 1 1, 2 0->1 a 1->F1 1->1 b 2 3 1->2 a 2->F2 2->2 b

The states of this automaton are decorated with metadata: the corresponding set of states of the input automaton. Use strip to remove this decoration.

In [12]: 
a3.determinize().strip().complete()
Out[12]:
%3 I0 0 0 I0->0 F1 F2 1 1 0->1 a 3 3 0->3 b, c 1->F1 1->1 b 2 2 1->2 a 1->3 c 2->F2 2->2 b 2->3 a, c 3->3 [a-c]

Note that useless states and transitions are gray.

To evaluate a word on an automaton, use eval(), or simpler yet: use the automaton as if it were a function:

In [13]: 
a3.eval("a")
Out[13]:
$\top$
In [14]: 
a3("b")
Out[14]:
$\bot$

To see the 10 first accepted words (if there are that many), use shortest(10):

In [15]: 
a3.shortest(10)
Out[15]:
$a \oplus \mathit{aa} \oplus \mathit{ab} \oplus \mathit{aab} \oplus \mathit{aba} \oplus \mathit{abb} \oplus \mathit{aabb} \oplus \mathit{abab} \oplus \mathit{abba} \oplus \mathit{abbb}$

To extract a rational expression from the automaton, use ratexp():

In [16]: 
a3.ratexp()
Out[16]:
$a \, {b}^{*} + a \, {b}^{*} \, a \, {b}^{*}$

Voilà! You may now proceed to discover other features in other notebooks. Bon voyage!