(MIT6.045) Automata, Computability and Complexity - DFA and NFA

The graduation thesis is finished. Find something to do.
Buddhist update.

this is a tell

• What is calculation?
• What can be counted?
• How to calculate efficiently?

courses on philosophical, mathematical, and engineering issues.

mainly include:

1. Finite Avtomata: Simple model.

2. Computable theory.

3. Computational complexity theory: models constrained by time and space complexity.

The (mathematical) proofs covered in this course will mainly illustrate the idea of ​​a proof.

It is more important to explain the idea clearly than to write a bunch of details (it is not a mathematical analysis class

Deterministic Finite Avtomata

A simple example: calculate whether there is an odd number of 1s or an even number of 1s in a string of all 1s.

The state machine starts from $q_0$start. Given a string (limited length) of 111...111, read one character (1) each time, and perform state transition according to the transition rules of the state at this time until the end of reading.

Detailed explanation of DFA:

There is an entry (initial state) and a string. When the character meets the condition, it needs to transition from state A to state B. There are terminal states (represented by concentric circles).

If starting from the initial state, the state follows the order of the characters in the string and the state transition logic to transform, and finally stops at the termination state (concentric circle state), it means that DFA accepts the string, otherwise, DFA rejects the string.

A more formal definition is as follows:

A DFA is defined as a quintuple. State set, character set $\Sigma$ (such as {0, 1}, English alphabet, UTF-8), start state, end state set, state transition function.

Language: Language is $2^{}$A subset of${}^{\Sigma \; .}$For example,$\Sigma$ is the English alphabet, and language L can be all words starting with a in English, or all words containing sh*t.

In other words, a language is a function that takes a string as input and outputs 0 or 1.

L(M) = language defined by a deterministic finite state machine M.

Note that $\ast \to q_0$, means: $q_0$is an initial state and a terminal state.

We can also extend the state transition function of DFA, and recursively define the "extended" state transition function when the input is a string:

Proofs for Finite Automata:

What does this automaton say? (In other words, which grammars match the above automata?)
How to prove that the grammar we got is correct?

The automaton above matches strings that have an odd number of 0s and end with a 1.

Proof:
$q_0$State: There are even number of 0
$q_1$Status: There are an odd number of 0, and the end is 0
$q_2$Status: There are an odd number of 0s and the end is 1

The rest can be solved by mathematical induction.

Definition: A language L' is regular if L' can be described by DFA. That is, there exists M such that: L' = L(M).

Union Theorem of Regular Languages:
Given two regular languages $L_i,i=1,2$。$L_1\cup L_2=w|w\in L_i,i=1||i=2$ .
Then,$L_1\cup L_2$Also regular.

Proof idea: mainly consider the parallel operation of two DFAs. For a regular language $L_i$, we consider the corresponding DFA, denoted as $M_i$. Consider $M_i$The state of $Q_i$, as Cartesian product $Q_1\times Q_2$. Then construct the transition rules that meet the two DFAs.

The Intersection Theorem of Regular Languages:
Given two regular languages $L_i,i=1,2$。$L_1\cap L_2=w|w\in L_i,i=1\&\&i=2$ .
Then,$L_1\cap L_2$Also regular.

Proof idea: still consider the parallel operation of two DFAs.

Complementation Theorem:
Given a regular language $L$，$L^C$ is also a regular language.
Proof: Just flip the terminal set and non-terminal set over.

Language inversion $L^{R.}$ _ For example:${0,10,110,0101}^R=0,01,011,1010$。

Inversion theorems for regular languages.
An inverted regular language is also a regular language. For every DFA-readable language that can be read from right to left, there is a corresponding DFA-readable language that can be read from left to right.
But how to prove it?
We wish: Given a DFA $M$ , the corresponding regular language is$L$ , able to construct a$M^R$ , such that$M^R$ accepts$w^R$ if and only if$M$ accepts$w$。

A simple try: invert all arrows and set states of M. But in this way of operation, there will be problems:

$M^R$ is not always a DFA.

For example, there may be many initial states, and for a given state and input, there may be multiple (or none) transition rules.

So we introduce:

Non-Deterministic Finite Avtomata

First, we consider a DFA:

the DFA $M$ accepts strings containing 001.

We consider $M^R$。

In the new automaton shown above, for a string, if there is a path that allows the state to reach the final state, then we consider the logic to be accepted.

Another type of NFA: $ϵ$ -NFA. Here$ϵpath$ means empty hop, which can transfer state without accepting characters.

For example: in the case of multiple starting states, it can be expressed as follows:

The state transition function in NFA $d(q,char)$ may return a collection of states. Of course, this set may also be an empty set.

For DFAs:

1. When the state and input are given, the transfer function value of DFA is deterministic (Deterministic).
2. A DFA accepts a string if and only if this string will take the DFA to an end state.

For NFAs:

1. For a given string, NFA may choose one of many different paths.
2. An NFA accepts strings if and only if this string "may" lead the NFA to an end state.

In DFA, the expanded state transition function $\hat{d}(state,string)$ can eat the next string.

In NFA, such operations can also be defined. If NFA has initial state $q$ , then the string$x$ is grammatical if and only if$\hat{d}(q,x)\cap F\ne \varnothing$ . Among them, F is the terminal state set.

Recursive definition of NFA:

Definition of the set of states in NFA. Suppose $P$ is a state set, then
$$d(P,a)={\cup }_{q\in P}d(q,a)$$

An example of an NFA:

Given the string str = 10101, how does the above NFA perform?

• $F=q_2$
• $\hat{d}(q_0,10101)=q_0,q_2$
• $q_0,q_2\cap F=q_2$
  The string 10101 then conforms to the above NFA.

In general, NFA is more convenient to use than DFA.

Are NFA and DFA equivalent?
Yes.

Theorem: For any NFA $N$ , there exists a DFA$M$ such that$L(M)=L\left(N\right)$。

Specific ideas: For NFA, we can directly construct DFA by constructing the power set of the state set.