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 (too) short tutorial guides you through the Python binding of Vcsn, and more specifically the IPython interface. If you are not a Python programmer, rest assured that there is not much to know, 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.

Once you read this page, you should explore these:

- Read me first - This page.
- Contexts - The typing system for automata, expressions, etc.
- Automata - How to define or edit automata.
- Expressions - The definition of the rational expressions.
- Algorithms - Index of the available operations on automata, expressions, etc.
- The C++ Library - Tutorial on how to use the Vcsn C++ library.
- Executables - Executables to run from the shell, easy to chain via pipes.
- Trouble-Shooting - Some known problems (during build or use), and a few known solutions.
- Stackoverflow - Some questions asked on Stackoverflow where Vcsn can compute the answer.
- References - Publications on the algorithms and constructs used in Vcsn.
- ICTAC-2016 - Show examples taken from a paper presented to ICTAC 2016.
- CIAA-2016 - Show examples taken from a paper presented to CIAA 2016.
- Hacking - Random notes, badly written, obsolete, meant for Vcsn developers.

Additional material is available on the web:

- The Vcsn Website contains more information, tarballs, etc.
- The Vcsn Sandbox offers a playground to experiment with Vcsn from a web browser.
- The Vcsn Gitlab is the right place to submit bug reports.

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 shell interface (Executables).

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" menu, and select "Python" (or "Python 3"), 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]:

`ctx.expression`

as follows:

In [2]:

```
e1 = ctx.expression("ab*")
e1
```

Out[2]:

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`

For more details, please see the documentation of expressions.

So for instance `e1`

denotes the words starting with a single `a`

followed by any number of `b`

s.

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

In [3]:

```
e1.shortest(10)
```

Out[3]:

`+`

for sum, `*`

for multiplication (concatenation):

In [4]:

```
e1 + e1 * e1
```

Out[4]:

In [5]:

```
e1.standard()
```

Out[5]:

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

The expression.derived_term method builds the "derived-term automaton", aka, the Antimirov automaton.

In [6]:

```
a1 = e1.derived_term()
a1
```

Out[6]:

In [7]:

```
a2 = (e1 + e1*e1).derived_term()
a2
```

Out[7]:

In [8]:

```
a3 = a1 + a1 * a1
a3
```

Out[8]:

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

In [9]:

```
a2.is_equivalent(a3)
```

Out[9]:

All the classical algorithms about automata are implemented:

In [10]:

```
a3
```

Out[10]:

In [11]:

```
a3.determinize()
```

Out[11]:

In [12]:

```
a3.determinize().strip().complete()
```

Out[12]:

Note that useless states and transitions are grayed.

`eval()`

, or simpler yet: use the automaton as if it were a function:

In [13]:

```
a3.eval("a")
```

Out[13]:

In [14]:

```
a3("b")
```

Out[14]:

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

In [15]:

```
a3.shortest(10)
```

Out[15]:

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

:

In [16]:

```
a3.expression()
```

Out[16]: