✎ 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>

===== 2.1. The class Dfa (Python) =====

**2.1.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

**Optional:** you may consider defining a class ''State'' to encode more general Dfas where states are not confined to integers. This will be useful later in your project. However, you will need to define a hash-function in order to use dictionaries over states. More details, google ''hashing in Python''.

**2.1.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.

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

**2.1.3.** Implement a member function which takes a **configuration** (pair of state and rest of word) and returns the next configuration.

**2.1.4.** Implement a member function which verifies if a word is **accepted** by a Dfa.

===== 2.2. The Dfa Algebraic Datatype (Haskell) =====

During the lecture, Dfa states were encoded as integers. As we will soon see, we will need to provision our implementation, so that other types may encode states.
  * Should the ADT ''DFA'' be **monomorphic** or **polymorphic**?

Also, we shall require a few constraints on what a proper state type should be. States should be: (i) **comparable** via equality, (ii) support an **ordering**. Later on we may add:
  * new constraints
  * **operations** which are specific to states only.

How can we **group** all these constraints and support for future state operations?

Finally, in order to encode transitions, we need the ''Map'' and ''Set'' datatypes which are available in their own modules:
<code haskell>
{- We do import the data constructor Map and the infix function (!) as unqualified, to make them easier to use (Map.Map and Map.(!) is not very legible) -}
import Data.Map (Map, (!))
{-
the keyword qualified forces us to prefix each function call from the module Data.Map with "Map." this is useful for two reasons:
   - some function names overlap
   - it makes the code more legible, by making the programmer aware of the module location of the called function
-}
import qualified Data.Map as Map

import Data.Set (Set)
import qualified Data.Set as Set
</code>

**2.2.1.** Implement the datatype ''DFA''. It must store:
  * the alphabet
  * the delta function
  * the initial state
  * the set of final states

**2.2.2.** Define a function which takes a string of the following form showed below, and returns a DFA:
<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.

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

**2.2.3.** Enroll the DFA type in class Show.

**2.2.4.** Implement function which takes a DFA and a **configuration** (pair of state and rest of word) and returns the next configuration.

**2.2.5.** Implement a function which verifies if a word is **accepted** by a Dfa.


===== 2.3. Dfa practice =====

Write Dfas and test them using your implementation, for the following languages:

  * **2.3.1.** $ L=\{w \in \{0,1\}^* \text{ | w contains an odd number of 1s} \} $
  * **2.3.2.** The language of binary words which contain **exactly** two ones
  * **2.3.3.** The language of binary words which encode odd numbers (the last digit is least significative)
  * **2.3.4.** (hard) The language of words which encode numbers divisible by 3.