The Vcsn platform relies on a central concept: "contexts". They denote typing information about automata, rational expressions, etc. This information is alike a function type: an input type (the *label*), and an output type (the *weight*).

Contexts are created by the `vcsn.context`

function which takes a string as input. This string follows the following syntax:

```
<context> ::= <labelset> , <weightset>
```

i.e., a context name is composed of a labelset name, then a comma, then a weightset name.

Different *LabelSets* model multiple variations on *labels*,
members of a monoid:

`letterset<`

*genset*`>`

Fully defined by an alphabet $A$, its labels being just letters. It is simply denoted by $A$. It corresponds to the usual definition of an NFA.`nullableset<`

*labelset*`>`

Denoted by $A^?$, also defined by an alphabet $A$, its labels being either letters or the empty word. This corresponds to what is often called $\varepsilon$-NFAs.`wordset<`

*genset*`>`

Denoted by $A^*$, also defined by an alphabet $A$, its labels being (possibly empty) words on this alphabet.`oneset`

Denoted by $\{1\}$, containing a single label: 1, the empty word.`tupleset<`

*labelset1*`,`

*labelset2*`, ...,`

*labelsetn*`>`

Cartesian product of LabelSets, $L_1 \times \cdots \times L_n$. This type implements the concept of transducers with an arbitrary number of "tapes". The concept is developed more in-depth here: Transducers.

The gensets define the types of the letters, and sets of the valid letters. There is currently a single genset type.

`char_letters`

Specify that the letters are implemented as`char`

. Any`char`

will be accepted. The genset is said to be "open".`char_letters(abc...)`

Specify that the letters are implemented as`char`

, and the genset is closed to`{a, b, c}`

. Any other`char`

will be rejected.

There are a few abbreviations that are accepted.

`lal_char`

:`letterset<char_letters>`

`lal_char(abc)`

:`letterset<char_letters(abc)>`

`lan_char`

:`nullableset<letterset<char_letters>>`

`law_char`

:`wordset<letterset<char_letters>>`

The *WeightSets* define the semiring of the weights. Builtin weights include:

`b`

The classical Booleans: $\langle \mathbb{B}, \vee, \wedge, \bot, \top \rangle$`z`

The integers coded as`int`

s: $\langle \mathbb{Z}, +, \times, 0, 1 \rangle$`q`

The rationals, coded as pairs of`int`

s: $\langle \mathbb{Q}, +, \times, 0, 1 \rangle$`qmp`

The rationals, with support for multiprecision: $\langle \mathbb{Q}_\text{mp}, +, \times, 0, 1 \rangle$`r`

The reals, coded as`double`

s: $\langle \mathbb{R}, +, \times, 0, 1 \rangle$`zmin`

The tropical semiring, coded as`int`

s: $\langle \mathbb{Z} \cup \{\infty\}, \min, +, \infty, 0 \rangle$`rmin`

The tropical semiring, coded as`floats`

s: $\langle \mathbb{R} \cup \{\infty\}, \min, +, \infty, 0 \rangle$`log`

The log semiring, coded as`double`

s: $\langle \mathbb{R} \cup \{-\infty, +\infty\}, \oplus_\mathrm{log}, +, +\infty, 0 \rangle$ (where $\oplus_\mathrm{log}$ denotes $x, y \rightarrow - \mathrm{log}(\exp(-x) + \exp(-y))$.`f2`

The field: $\langle \mathbb{F}_2, \oplus, \wedge, 0, 1 \rangle$ (where $\oplus$ denotes the "exclusive or").`tupleset`

Cartesian product of WeightSets, $W_1 \times \cdots \times W_n$.

The usual framework for automaton is to use letters as labels, and Booleans as weights:

In [1]:

```
import vcsn
vcsn.context('lal_char(abc), b')
```

Out[1]:

In [2]:

```
vcsn.context('lal_char(abc), z')
```

Out[2]:

To use words on the usual alphabet as labels:

In [3]:

```
vcsn.context('law_char(a-z), z')
```

Out[3]:

To create a "classical" two-tape automaton:

In [4]:

```
vcsn.context('lat<lal_char(a-f), lal_char(A-F)>, b')
```

Out[4]:

To compute a Boolean and an integer:

In [5]:

```
vcsn.context('lal_char(ab), lat<b, z>')
```

Out[5]:

The interpretation of the following monster is left to the reader as an exercise:

In [6]:

```
vcsn.context('lan<lat<lal_char(ba),lat<lan_char(vu),law_char(x-z)>>>,'
+' lat<expressionset<lan<lat<lan_char(fe),lan_char(hg)>>, lat<r, q>>, lat<b, z>>')
```

Out[6]: