Languages.

A Language is set of finite length strings on the symbol set

E
i.e. a subset of
*
E

(a b c a c d f g g g)
At this point, we dont care how the language is
generated or represented. So initially the comments
apply to all kinds of languages
-regular

=
-regular
-push-down automata languages
-Petri net languages
A symbol can be made up of a vector of
variable values, e.g. 1a3de0 or 010010.
These are examples of a single symbol.
Languages can be manipulated as follows:

Examples of Languages
Alphabet E = {a, b, c}. Language includes all the strings, in
which all occurrences of a appear before all occurrences of b:
C, a, b, c, ab, ac, acb, cab, aacaabbbccb,
Strings not in the language:
ba, aacabbaccc,
Binary variables x, y. E
x
= E
y
= {0,1},
E = E
x
E
y
= {00, 01, 10, 11}. Language includes all the
strings appearing as input/output combinations of the given
circuit (reset to 0):
(00), (10), (00)(00)(00), (00)(10)(11),
Strings not in the language:
(01), (11), (00)(01),
DFF
x y
1 2 1 2
{ | or } L L L L o o o = e e
-Intersection -
1 2 1 2
{ | } L L L L o o o = e . e
-Complement -
*
{ | } L L o o o = eE . e
-Catenation -
1 2 1 2
{ | } L L L L o | o | = e . e
Union
Lowering and Raising
-Given a Language
L
over the alphabet
X Y
projection is defined as
{{ }| {( )} }
i i i
X X Y
X
L L o o o
+
= e
-Given a Language L over the alphabet X lifting
to the alphabet X Y
is defined as -
{{( )}| { } }
i i
X X
Y
L L o o
|
= e

Examples of Projection and Lifting
Binary variables x, y, z. E
x
= E
y
= E
z
= {0,1}.
E
xyz
= E
x
E
y
E
z
= {000, 001, 010, 011, 100, 101, 110, 111}.
Language includes all the strings that can appear as
input/output combinations of the given circuit (reset to 0):
C,(000), (110)(001)(100),
Projecting to alphabet E
xz
:
(00), (10)(01)(10),
Lifting to alphabet E
xyzu
= E
xyz
E
u
:
(000-), (110-)(001-)(100-), =
(0000), (0001),
(1100)(0010)(1000),
(1100)(0010)(1001),
(1100)(0011)(1000),
DFF
x z
y
-Given a Language L over the alphabet
X Y
the restriction to X is defined as -
{{ ( )}| { } }
X i i
X
L p L o o

= e
where
if
( )
otherwise
i i
X i
X
p
o o
o
c
e

=
`
)
-Given a Language L over X and an alphabet Y disjoint
from X, the expansion of L is defined as the language
Y
L
l
over
X Y
such that -
*
{{ }| { } , }
i i i i i i
Y
L x x L Y o | o |
l
= e . e
Regular Expressions.
Regular Expressions over alphabet
E
{} is a regular expression
c
is a regular expression

|
i i
o o eE are regular expression
If r and s are regular expressions then
r+s, r s, and
*
r
are regular expressions.
The language associated with a regular expression
is called a regular language.
Theorem: The complement of a regular language
is a regular language
Examples of Regular Expressions
Regular expression a +b stands for {a,b}
Regular expression ab stands for {ab}
Regular expression a* stands for {C,a, aa, aaa, aaaa, }
Alphabet E = {a, b, c}. Language includes all the strings, in
which all occurrences of a appear before all occurrences of b:
(a+c)*(b+c)*
Alphabet E = E
x
E
y
= {00, 01, 10, 11}. Language includes
all the strings appearing as input/output combinations of the
given circuit (reset to 0):
( (00)*(10)(11)*(01) )*

DFF
x y 0 1
00
10
11
01
Classes of Languages
-A language is prefix closed if
*
, ,[ ] L L o o o o o eE eE e e
-A language over
I O E =
is I-progressive if
*
, , [ ] i I o O L io L o o o eE e - e e e
-A language over
I O E =
is I-Moore if
, ( ) , ( ' ')
[ [ ' ' ( ' ) ]]
L io i o
io L i o L i o L
o
o o o
e eE eE
e e e
Examples of Languages
Prefix-closed language includes, with its every string, all the
prefixes of this string.
Example 1: Language a*b* is prefix closed
Example 2: Language a*b is not prefix closed
I-progressive language includes the strings, which, for each
input symbol, have some output symbol
Example 1: Language ( (00)*(10)(11)*(01) )* is I-progressive
Example 2: Language ( (00)*(10)(01) )* is not I-progressive

0 1
00
10
11
01
0 1
00
10
01
Classes of Languages
-A language
*
( ) L I O _
over
I O
is prefix closed if
*
( ) , ,[ ] I O i o I O i o L L o o o e e e e
A language
*
( ) L I O _
over
I O
is IO-progressive if
*
( ) , , ,[ ] I O i I o O L i o L o o o e e - e e e
Composition of Languages
-Given disjoint alphabets I,U,O and languages L
1
over
I U
and L
2
over
U O
, their synchronous composition is
1 2
[( ) ( ) ]
O I I O
L L
| | +

.
-Given disjoint alphabets I,U,O and languages L
1
over
I U
and L
2
over
U O
, their parallel composition is
1 2
[( ) ( ) ]
O I I O
L L
l l

.
Synchronous Composition
Spec is defined over IO
Fixed is defined over IVUO
Unknown should be over UV

The solution to the equation
F - X _ S
is

More specifically

S F X - =
I
O
V U
Fixed
Unknown
F
X
Specification
S
) , ( ) , (
] [ ) , ( ) , , , (
V U U V
O I S O U V I F X
+ |
- =
S F X - =
While synchronous product often is thought to be a simple
even uninteresting type of coordination, it can be shown
that, through the use of non-determinism, this conceptually
simple coordination serves to model the most general
asynchronous coordination, i.e. where processes progress
at arbitrary rates relative to one another. In fact the interleaving
model, the most common model for asynchrony in the software
community, can be viewed as a special case of this synchronous
product
Kurshan, 1994.


Uses non-determinism and self loops with null transitions
at each state to model parallel with synchronous.
Finite Automata
A finite automaton (FA) is
( , , , , ) F S r Q o = E
where S is a set of states,
E
is an input alphabet,
( , ) : 2
S
s S o o E
is a transition relation, r is the initial state, and
Q S _
is the set of accepting states.
An input sequence
*
1
( ... )
n
w w w = eE
leads from r to s if there exists a sequence of states,
0 1
( ... ')
n
r s s s s = =
such that
1
( , )
i i i
s s w o
+
e
for all i = 0, ... ,n-1.



w is in the language of F ( ) ( ) w F eL
if and only if w leads from r to ' s Q e
i.e.
( , ) r w Q o = C where ( , ) r w o
denotes the set of states that can be reached from r
under the input sequence w.
Examples of Finite Automata

Example 1: Language a*b* is prefix closed
Example 2: Language a*b is not prefix closed

X Y
a
b
X Y
a
b
b
Theorem: A languages is regular if and only if it is the
language of a finite automaton


Theorem: The set of all languages for deterministic
FA is the same as for non-deterministic FA.
(we will show how this can be done using the so-
called subset construction.)

Operations on FA.
-projection (
X
F
+
): convert F over X V
into F over X by replacing each edge (xv s s) by the
edge (x s s)




-lifting (
V
F
|
): convert F over X into F over X V
by replacing each edge (x s s) by
( ')
V
x s s where V

stands for any v V e

.
Examples of Projection and Lifting
0 1
000
010
100
110
111
001
0111
01
Projection +y
0 1
00
10
10
11
01
11
0 1
000-
010-
100-
110-
111-
001-
011-
101-
Lifting |u
DFF
x z
y
u
Note: Automaton after projection
is non-deterministic
-restriction (
X
F

): convert F over X V
to F over V, by changing every edge (v s s) where
v V e
into ( )
' s s c

-expansion (
V
F
l
): Change F over X into F over
X V
by adding for each state, a self-loop for all v, i.e. add an edge
( )
V
s s where V

stands for any

v V e
Operations on FA.
Product
Given FAs
1 2
and F F both over
E
, the product is
1 2 1 2 1 2 1 2
( , , , ( ), ) F FF S S r r Q Q o = = E
where
1 2 1 1 2
( , ) ( , ) ( , ) s s s s o o o o o o =
Complementation
If F is deterministic, then
( , , , , ) F S r Q S Q o = E =
.

If F is non-deterministic, the only known way for
complementation is to determinize it first. This is
done by the sub-set construction.
Example of Product of Automata

Composition
Synchronous Composition. Given two automata
1
F
and
2
F
over alphabets I U and U O
their synchronous composition is
1 2 1 2
( ) ( )
O I
F F F F
| |
- =
i.e. the product of the two automata when they are
made to have the same alphabet.

Parallel Composition. Given two automata
1
F and
2
F on alphabets I U and U O
their synchronous composition is
1 2 1 2
( ) ( )
O I
F F F F
l l
=
i.e. the product of the two automata when they are made
to have the same alphabet.
Subset Construction
Given NFA
( , , , , ) F S r Q o = E
we create a DFA F with the same language as F:
' (2 , , ',{ }, ')
S
F r Q o = E
where ' { ' 2 | , '}
S
q Q
Q s q s
e
= e - e
and
'
'( ', ) { | , ( , )}
s s
s s s s o o o o
e
= - e

s
Theorem: F and F have the same language.
Proof: ( , ) '({ }, ) q r w q r w o o e e


Interpretation of Subset Construction
Non-deterministic automaton (NDA) can transit into several states under
the same input
We can think of these transitions happening at the same time
It means that the NDA can be in several states at the same time
If string s has driven an NDA into a subset of states containing at least
one accepting state, s is accepted
Non-determinism is useful to compactly represent languages, but
manipulation of NDAs is hard
Determinization consists in constructing a DA equivalent to the given NDA
Determinization procedure performs subset construction
The idea of subset construction is to transform (unfold) the NDA,
which can be in a subset of states, into a DA, which can only be in one
state, by associating each subset of states of the NDA with one state of
the DA
Example of Subset Construction
0 1
00
10
10
11
01
11
Finite State Machines as Automata

A FSM is ( , , , , ) M S I O T r =
where I is the set of input symbols, O the set of output
symbols, r the initial state, and T(s,i,s,o) is the transition
relation. A transition (s,i,s,o) from state s to s with
output o can happen on input i can if and only if
( , , ', ) ( , , ', ) s i s o T s i s o e

If
( , ) ( ', )[( , , ', ) ] s i s o s i s o T - e
then M is complete, otherwise partial.
It is deterministic if for all (s,i) there is at most one (s,o)
such that
( , , ', ) s i s o F e

It is pseudo-non-deterministic if for all (s,i,o) there is at
most one s such that
( , , ', ) s i s o F e
A FSM is of Moore type if
( , , ', ) ' '[( , ', ', ) ] s i s o T i n s i n o T e - e
i.e. i can determine the next state but not the output.
Examples of FSMs
0 1
0/0
1/0
1/0
1/1
0/1
DFF
x z
y
0 1
00/0
01/0
10/0
11/0
11/1
00/1
01/1
10/1
Deterministic FSM
Non-Deterministic FSM
Circuit
0 1
0/0
1/0
1/1
1/1
0/1
Pseudo-Non-Deterministic FSM
Converting an FSM to an automaton
An FSM M can be converted into an automaton F by the
following: ( , ( ), , , ) F S I O r S o =
where ( , ) { ' | ( , , ', ) } s io s s i s o T o = e

Note that Q = S, i.e. all states are accepting
The resulting automaton is typically not complete, since
there are io combinations for which a next state is not
defined. We can complete it by augmenting
o
to include a transition to a new non-accepting state DCN.
DCN
s
f
f
Converting FSM into Automaton
0 1
00/0
01/0
10/0
11/0
11/1
00/1
01/1
10/1
FSM
0 1
000
010
100
110
111
001
0111
01
Incomplete Automaton
Complete Automaton
0 1
000
010
100
110
111
001
0111
01
001
0111
0111
1
000
010
1001
10
3
- - -
FSMs as Automata
The language of an FSM is defined to be the language of the
associated automaton
A pseudo non-deterministic FSM is one whose automaton
is deterministic.
The language of an FSM is prefix closed.
The language of an FSM is I-progressive


Conversion M F
is done by grouping i/o on edges to (io) and making all
states accepting.

Conversion
F M
can be done only if the language is prefix closed and
I-progressive. In this case, delete all non-accepting states
(prefix), and change edges from (io) to i/o.