✎ lfa:lab02-dfa [books]

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== 2. Deterministic finite automata ======

===== Classes in Python =====

Python supports a limited version of Object-Oriented programming, which includes **class definitions** and **inheritance**. The concept of **interface** and **interface implementation** is absent. Hence, when inheriting a function, it is the job of the programmer to make sure a method is overloaded correctly (otherwise it is just another definition of the class).

Below, we illustrate some examples of Python's object-oriented idiom:

<code python>
class Example:
   # the class constructor.
   def __init___(self,param1,param2):
      # the keyword self is similar to this from Java
      # it is the only legal mode of initialising and referring class member variables
      self.member1 = param1  
      # here member2 is a local variable, which is not visible outside of the constructor
      member2 = param2
   
   def fun(self):
      # a member function must always refer self as shown here. Otherwise it is just a function
      # defined in the scope of the class, not a member function.
      return 0
   
   def plus(self,x,y):
      return x + y
   
   # this is the equivalent of Java's toString method
   def __str__(self):
      string = ...
      return string
   
#global scope

#class instantiation
e = Example(1,2) 

#method calls:
e.fun()

print(e)
</code>

===== The class Dfa =====

2.1. Define the class ''Dfa'' which encodes deterministic finite automata. It must store:
 - the alphabet
 - the delta function
 - the initial state
 - the set of final states

2.2. Define a constructor for Dfas, which takes a multi-line string of the following form:

<code>
<initial_state>
<state> <char> <state>
...
...
<final_state_1> <final_state_2> ... <final_state_n>
</code>

where:
  - the initial state is given on the first line of the input
  - each of the subsequent lines encode transitions (states are integers)
  - the last line encodes the set of final states.

2.3. Implement



====== [Deprecated] Deterministic finite automata ======

==== 1. Writing DFAs ====
1.1. Write a DFA which accepts the language $ L=\{w \in \{0,1\}^* \text{ | w contains an odd number of 1s} \} $
Hint:
  * in a DFA, delta is total!

1.2 Define a DFA which accepts arithmetic expressions. Consider the following definition for arithmetic expressions:

<code>
<expr> ::= <var> | <expr> + <expr> | <expr> * <expr>
<var> ::= a | b
</code>

Hint:
  * how would you define the alphabet for the DFA?
  * can <expr> be the empty string?

==== 2. Implementing DFAs ====
Consider the following encoding of a DFA:
<code>
   <number_of_states>
   <list_of_final_states>
   <state> <symbol> <state>
</code>

Example:
<code>
4
2 3
0 a 1
1 b 2
2 a 0
</code>

2.1. Write a function which takes a DFA encoding as above and returns a DFA representation. Define a class "DFA".

2.2. Add a method accept which takes a word and returns true if it is accepted by the DFA

2.3. Add a method step with takes a DFA configuration and returns the "next-step" configuration of the DFA. How is a configuration defined?

2.4(*) Write a method which:
  * takes a list of DFAs $ a_1, a_2, ..., a_n$
  * takes a string $ s$. We know the string consists of a sequence of words, each accepted by some dfa in the list.
  * returns a list of pairs $ (w_1,a_1), ...(w_i,a_i) ... (w_n,a_n)$ such that $ w_1w_2... w_n = s$ and the dfa $ a_i$ accepts word $ w_i$, for each i from 1 to n.

Example:
<code>
l = [a1, a2, a3]
 ''' 
    a1 accepts sequences of digits [0-9]
    a2 accepts sequences of lowercase symbols [a-z]
    a3 accepts operands (+ and *)
 '''
s = "var+40*2300"

our function returns:
[("var",2), ("+",3), ("40",1), ("*",3), ("2300",1)]
</code>