expression
.expansion()
¶Compute the expansion of a weighted expression. An expansion is a structure that combines three different features of a (weighted) rational expression $r$:
If one denotes $d(r)$ the expansion of $r$, it holds that: $$ d(r) = c(r) \oplus \bigoplus_{a \in f(r)} a \odot \frac{\partial}{\partial a}r $$
The main use of expansions (and derivations) is to compute the derived-term automaton of an expression. The advantage of expansions over derivations is their independence with respect to the alphabet. As a matter of fact, they do not require a finite-alphabet (see examples below). Besides, the reunite constant-term, first, and derivation into a single concept.
See also:
References:
The following function will prove handy to demonstrate the relation between the expansion on the one hand, and, on the other hand, the constant-term and the derivations. It takes an expression $r$ and a list of letters, and returns a $\LaTeX$ aligned
environment to display:
import vcsn
from IPython.display import Latex
def diffs(e, ss):
eqs = [r'd\left({0:x}\right) &= {1:x}'.format(e, e.expansion()),
r'c\left({0:x}\right) &= {1:x}'.format(e, e.constant_term())]
for s in ss:
eqs.append(r'\frac{{\partial}}{{\partial {0}}} {1:x} &= {2:x}'
.format(s, e, e.derivation(s)))
return Latex(r'''\begin{{aligned}}
{eqs}
\end{{aligned}}'''.format(eqs=r'\\'.join(eqs)))
In the classical case (labels are letters, and weights are Boolean), this is the construct as described by Antimirov.
b = vcsn.context('lal_char(ab), b')
e = b.expression('[ab]{3}')
e.expansion()
Or, using the diffs
function we defined above:
diffs(e, ['a', 'b'])
Of course, expressions can be weighted.
q = vcsn.context('lal_char(abc), q')
e = q.expression('(<1/6>a*+<1/3>b*)*')
diffs(e, ['a', 'b'])
And this is tightly connected with the construction of the derived-term automaton.
e.derived_term()
There is (currently) no means to break an expansion (which would mean breaking its polynomials). The construction of the derived-term automaton does it on the fly.
Contrary to derivation, which requires a finite alphabet, expansions support labels which are words, or even tuples.
Below, we define a two-tape-of-words context, and a simple expression that uses three different multitape labels: $(\mathrm{11}|\mathrm{eleven})$, etc. Then derived_term
is used to build the automaton.
ctx = vcsn.context('lat<law_char(0-9), law_char(a-zA-Z)>, b')
ctx
e = ctx.expression("(11|eleven + 12|twelve + 13|thirteen)*")
e
e.expansion()
This enables the construction of the associated derived-term automaton.
e.derived_term()