# automaton.infiltrate¶

Create the (accessible part of the) infiltration product of two automata. In a way the infiltration product combines the conjunction (synchronized) and the shuffle product.

Preconditions:

• all the labelsets are letterized

## Examples¶

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

Out:
$\{\ldots\}\to\mathsf{Series}[\{\ldots\}\to\mathbb{Z}]$

The following simple example aims at emphasizing that the transitions of the infiltration combine those of the shuffle and the conjunction products.

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

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

Out:
In :
x & y

Out:
In :
x.shuffle(y)

Out:
In :
x.infiltrate(y)

Out:

Don't be mistaken though: if in this example the sum of the shuffle and conjunction products indeed match the infiltration product, this no longer applies to larger automata. In the following example (which nicely highlights the features of these three types of product) the transition from $(1, 0)$ to $(2, 1)$ would be missing.

In :
xx = x * x
xx

Out:
In :
yy = y * y
xx & yy

Out:
In :
xx.shuffle(yy)

Out:
In :
xx.infiltrate(yy)

Out:

### Associativity¶

This operator is associative.

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

In :
a = x.infiltrate(y).infiltrate(z); a

Out:
In :
b = x.infiltrate(y.infiltrate(z)); b

Out:
In :
a.strip().is_isomorphic(b.strip())

Out:
True

As a convenience, infiltrate is variadic: it may accept more than two arguments. However, it's (currently) only a wrapper around repeated calls to the binary operation (as can be seen by the parentheses in the state names below).
c = x.infiltrate(y, z); c

c.strip().is_isomorphic(a.strip())

True