# automaton & aut¶

The (accessible part of the) "conjunction" of automata.

Also Known As:

• synchronized product
• intersection

Preconditions:

• all the labelsets are letterized

## Examples¶

### Boolean Automata¶

In :
import vcsn


The synchronized product of Boolean automata computes the intersection of their languages. For instance, the conjunction of an automaton that accepts only words on $\{a, b\}$ with an odd number of $a$ with an automaton accepting with words with an odd number of $b$:

In :
%%automaton odda
$-> 0 0 -> 0 b 0 -> 1 a 1 -> 1 b 1 -> 0 a 1 ->$

In :
%%automaton oddb
$-> 0 0 -> 0 a 0 -> 1 b 1 -> 1 a 1 -> 0 b 1 ->$


is an automaton that accepts only words with odd numbers of $a$ and $b$:

In :
odda & oddb

Out:
In :
(odda & oddb).shortest(10)

Out:
$\mathit{ab} \oplus \mathit{ba} \oplus \mathit{aaab} \oplus \mathit{aaba} \oplus \mathit{abaa} \oplus \mathit{abbb} \oplus \mathit{baaa} \oplus \mathit{babb} \oplus \mathit{bbab} \oplus \mathit{bbba}$

### Weighted automata¶

In :
import vcsn
c = vcsn.context('lal_char, seriesset<lal_char, z>')
std = lambda exp: c.expression(exp).standard()

In :
x = std("<x>a*+<x>b*"); x

Out:
In :
y = std("<y>a*+<y>c*"); y

Out:
In :
x & y

Out:

### Associativity¶

This operator is associative, and it is actually implemented as a variadic operator; a & b & c is not exactly the same as (a&b)&c: they are the same automata, but the former is labeled with 3-uples, not 2-uples.

In :
x = std('<x>a')
y = std('<y>a')
z = std('<z>a')

In :
x & y & z

Out:
In :
xy = (x & y).__value__(); xy & z

Out:

The __value__ call here is an internal detail used to force Vcsn into the binary call. You should forget about it