Построение по НКА эквивалентного ДКА, алгоритм Томпсона — различия между версиями

Материал из Викиконспекты
Перейти к: навигация, поиск
(Построение эквивалентного ДКА по НКА)
(Алгоритм)
(Метки: правка с мобильного устройства, правка из мобильной версии)
 
(не показаны 42 промежуточные версии 10 участников)
Строка 1: Строка 1:
[[Категория: Теория формальных языков]]
+
== Описание ==
 +
Алгоритм Томпсона строит по [[Недетерминированные конечные автоматы|НКА]] эквивалентный [[Детерминированные конечные автоматы|ДКА]] следующим образом:
 +
* Начало.
 +
* '''Шаг 1.''' Помещаем в очередь <tex>Q</tex> множество, состоящее только из стартовой вершины.
 +
* '''Шаг 2.''' Затем, пока очередь не пуста выполняем следующие действия:
 +
** Достаем из очереди множество, назовем его <tex>q</tex>
 +
** Для всех <tex>c \in \Sigma</tex> посмотрим в какое состояние ведет переход по символу <tex>c</tex> из каждого состояния в <tex>q</tex>. Полученное множество состояний положим в очередь <tex>Q</tex> только если оно не лежало там раньше. Каждое такое множество в итоговом ДКА будет отдельной вершиной, в которую будут вести переходы по соответствующим символам.
 +
** Если в множестве <tex>q</tex> хотя бы одна из вершин была терминальной в НКА, то соответствующая данному множеству вершина в ДКА также будет терминальной.
 +
* Конец.
 +
 
 
== Построение эквивалентного ДКА по НКА ==
 
== Построение эквивалентного ДКА по НКА ==
  
Строка 5: Строка 14:
  
 
Построим по нему следующий ДКА: <tex>\langle \Sigma , Q_d, s_d \in Q_d, T_d \subset Q_d, \delta_d : Q_d \times \Sigma \to Q_d \rangle</tex>, где:
 
Построим по нему следующий ДКА: <tex>\langle \Sigma , Q_d, s_d \in Q_d, T_d \subset Q_d, \delta_d : Q_d \times \Sigma \to Q_d \rangle</tex>, где:
# <tex>Q_d = 2^Q</tex>,
+
# <tex>Q_d = \{q_d \mid q_d \subset 2^Q \}</tex>,
 
# <tex>s_d = \{s\}</tex>,
 
# <tex>s_d = \{s\}</tex>,
# <tex>T_d = \{q \in Q_d | \exists p \in T : p \in q\}</tex>,
+
# <tex>T_d = \{q \in Q_d \mid \exists p \in T : p \in q\}</tex>,
# <tex>\delta_d(q, c) = \bigcup\limits_{a \in q} \delta(a, c)</tex>.
+
# <tex>\delta_d(q, c) = \{ \delta(a, c) \mid a \in q \}</tex>.
  
 
===Доказательство эквивалентности===
 
===Доказательство эквивалентности===
Строка 15: Строка 24:
 
Построенный ДКА эквивалентен данному НКА.
 
Построенный ДКА эквивалентен данному НКА.
 
|proof=
 
|proof=
#Докажем, что любое слово, которое принимает НКА, будет принято построенным ДКА. Заметим, что <tex>\forall q \in q_d, \forall c \in \Sigma, \forall p \in \delta(q, c): p \in \delta_d(q_d, c)</tex>. Рассмотрим слово <tex>w=w_1...w_m</tex>, которое принимает автомат НКА: <tex>\langle s, w_1w_2...w_m \rangle \vdash \langle u_1, w_2...w_m \rangle \vdash \langle u_m, \varepsilon \rangle, u_m \in T</tex>. Проверим, что построенный ДКА тоже принимает это слово. Заметим, что <tex>s \in s_d</tex>, а, значит, исходя из нашего наблюдения, мы получаем, что <tex>u_1 \in {u_d}_1</tex>, где <tex>{u_d}_1 = \delta_d(s, w_1)</tex>. Далее, несложно заметить, что <tex>\forall i \leq m : u_i \in {u_d}_i</tex>, где <tex>\langle s_d, w_1w_2...w_m \rangle \vdash \langle {u_d}_1, w_2...w_m \rangle \vdash \langle {u_d}_i, w_{i + 1}...w_m\rangle</tex>. Таким образом, <tex>u_m \in {u_d}_m</tex>, а из определения терминальных состояний в построенном ДКА мы получаем, что <tex>{u_d}_m \in T_d</tex>, то есть наш ДКА тоже принимает cлово <tex>w</tex>.
+
#Докажем, что любое слово, которое принимает НКА, будет принято построенным ДКА. Заметим, что <tex>\forall q \in q_d, \forall c \in \Sigma, \forall p \in \delta(q, c): p \in \delta_d(q_d, c)</tex>. Рассмотрим слово <tex>w=w_1 \dots w_m</tex>, которое принимает автомат НКА: <tex>\langle s, w_1w_2 \dots w_m \rangle \vdash \langle u_1, w_2 \dots w_m \rangle \vdash \langle u_m, \varepsilon \rangle, u_m \in T</tex>. Проверим, что построенный ДКА тоже принимает это слово. Заметим, что <tex>s \in s_d</tex>, а, значит, исходя из нашего наблюдения, мы получаем, что <tex>u_1 \in {u_d}_1</tex>, где <tex>{u_d}_1 = \delta_d(s, w_1)</tex>. Далее, несложно заметить, что <tex>\forall i \leqslant m : u_i \in {u_d}_i</tex>, где <tex>\langle s_d, w_1w_2 \dots w_m \rangle \vdash \langle {u_d}_1, w_2 \dots w_m \rangle \vdash \langle {u_d}_i, w_{i + 1} \dots w_m\rangle</tex>. Таким образом, <tex>u_m \in {u_d}_m</tex>, а из определения терминальных состояний в построенном ДКА мы получаем, что <tex>{u_d}_m \in T_d</tex>, то есть наш ДКА тоже принимает cлово <tex>w</tex>.
#Докажем, что любое слово, которое принимает построенный ДКА, принимает и НКА. Сначала сделаем наблюдение, что если <tex>q_d=\{q\}</tex>, и мы из него достигли по строке <tex>S</tex> какого-то состояния <tex>p_d</tex>, то <tex>\forall p \in p_d</tex> существует путь из <tex>q</tex> в <tex>p</tex> в НКА по строке <tex>S</tex>. Рассмотрим слово <tex>w=w_1...w_m</tex>, которое принимает автомат ДКА: <tex>\langle s_d, w_1w_2...w_m \rangle \vdash \langle {u_d}_1, w_2...w_m \rangle \vdash \langle {u_d}_m, \varepsilon \rangle, {u_d}_m \in T_d</tex>. Проверим, что НКА тоже принимает это слово. Так как <tex>s_d = \{s\}</tex>, и мы из <tex>s_d</tex> достигли <tex>{u_d}_m \in T_d</tex>, возьмём любое терминальное состояние <tex>u_m \in {u_d}_m</tex>. По нашему наблюдению в НКА есть путь из <tex>s</tex> в <tex>u_m</tex> по строке <tex>w</tex>, а, значит, НКА принимает это слово.  
+
#Докажем, что любое слово, которое принимает построенный ДКА, принимает и НКА. Сначала сделаем наблюдение, что если <tex>q_d=\{q\}</tex>, и мы из него достигли по строке <tex>S</tex> какого-то состояния <tex>p_d</tex>, то <tex>\forall p \in p_d</tex> существует путь из <tex>q</tex> в <tex>p</tex> в НКА по строке <tex>S</tex>. Рассмотрим слово <tex>w=w_1 \dots w_m</tex>, которое принимает автомат ДКА: <tex>\langle s_d, w_1w_2 \dots w_m \rangle \vdash \langle {u_d}_1, w_2 \dots w_m \rangle \vdash \langle {u_d}_m, \varepsilon \rangle, {u_d}_m \in T_d</tex>. Проверим, что НКА тоже принимает это слово. Так как <tex>s_d = \{s\}</tex>, и мы из <tex>s_d</tex> достигли <tex>{u_d}_m \in T_d</tex>, возьмём любое терминальное состояние <tex>u_m \in {u_d}_m</tex>. По нашему наблюдению в НКА есть путь из <tex>s</tex> в <tex>u_m</tex> по строке <tex>w</tex>, а, значит, НКА принимает это слово.  
Таким образом, множества слов, допускаемых ДКА и НКА совпадают, то есть они эквивалентны.
+
Таким образом, множества слов, допускаемых ДКА и НКА, совпадают, то есть они эквивалентны.
 
}}
 
}}
  
Строка 25: Строка 34:
  
 
===Алгоритм===
 
===Алгоритм===
<tex>Q</tex> {{---}} очередь состояний, соответствующих множествам, состоящих из состояний НКА.
+
* <tex>\mathtt{P}</tex> {{---}} очередь состояний, соответствующих множествам, состоящих из состояний НКА.  
<tex>s</tex> {{---}} стартовое состояние НКА.
+
* <tex>\mathtt{Q_d}</tex> {{---}} массив множеств, соответствующих состояниям ДКА.
  <tex>Q</tex>.push({<tex>s</tex>})
+
* <tex>\mathtt{s}</tex> {{---}} стартовое состояние НКА.
  while not isEmpty(<tex>Q</tex>)
+
'''Automaton''' getDFAbyNFA(<tex>\langle \Sigma, Q, s, T, \delta \rangle</tex> : '''Automaton'''):
      <tex>Q</tex>.pop(<tex>q_d</tex>)
+
    <tex>P</tex>.push(<tex>\{s\}</tex>)
      for <tex>c \in \Sigma</tex>
+
    <tex>Q_d</tex> = <tex>\varnothing</tex>
           <tex>p_d</tex> = <tex>\varnothing</tex>
+
    '''while''' <tex>P</tex> <tex> \neq </tex> <tex>\varnothing </tex>
           for <tex>q \in q_d</tex>  
+
      <tex>P</tex>.pop(<tex>p_d</tex>)
             <tex>p_d</tex> = <tex>p_d \cup \delta(q, c)</tex>
+
      '''for''' <tex>c \in \Sigma</tex>
           if (<tex>p_d</tex> haven't been in <tex>Q</tex>)
+
           <tex>q_d</tex> = <tex>\varnothing</tex>
             <tex>Q</tex>.push(<tex>p_d</tex>)
+
           '''for''' <tex>p \in p_d</tex>
 +
             <tex>q_d</tex> = <tex>q_d \cup \{ \delta(p, c) \}</tex>
 +
           <tex>\delta_d(p_d, q_d)</tex> = <tex>c</tex>
 +
          '''if''' <tex>q_d \notin Q_d</tex>
 +
            <tex>P</tex>.push(<tex>q_d</tex>)
 +
             <tex>Q_d</tex>.add(<tex>q_d</tex>)          
 +
    <tex>T_d</tex> = <tex>\{q_d \in Q_d \mid \exists p \in T : p \in q_d\}</tex>
 +
    '''return''' <tex>\langle \Sigma, Q_d, \{s\}, T_d, \delta_d \rangle</tex>
  
 
===Асимптотика===
 
===Асимптотика===
Строка 41: Строка 57:
  
 
===Пример===
 
===Пример===
Пусть нам дан исходный автомат [[Файл:DKA.jpg]].
+
Пусть нам дан [[Недетерминированные конечные автоматы|недетерминированный конечный автомат]]:
 +
 
 +
[[Файл:DKA.png|250px]]
 +
 
 +
По нашему заданию эквивалентного ДКА мы получаем:
 +
 
 +
[[Файл:NKA_definition.png|250px]]
 +
 
 +
#Помещаем в очередь множество из одной стартовой вершины — <tex>\{1\}</tex>: <tex>Q = \{\{1\}\}</tex>.
 +
#Достаём из очереди множество <tex>\{1\}</tex>: <tex>Q = \{\}</tex>.
 +
#<tex>q_d(\{1\}, a) = \{1, 2\}</tex>, кладём множество <tex>\{1, 2\}</tex> в очередь: <tex>Q = \{\{1, 2\}\}</tex>.
 +
#<tex>q_d(\{1\}, b) = \{1\}</tex>, нам не надо класть множество <tex>\{1\}</tex> в очередь, так как оно уже там было.
 +
#Достаём из очереди множество <tex>\{1, 2\}</tex>: <tex>Q = \{\}</tex>.
 +
#<tex>q_d(\{1, 2\}, a) = \{1, 2\}</tex>, нам не надо класть множество <tex>\{1, 2\}</tex> в очередь, так как оно уже там было.
 +
#<tex>q_d(\{1, 2\}, b) = \{1, 2\}</tex>, нам не надо класть множество <tex>\{1, 2\}</tex> в очередь, так как оно уже там было.
 +
#Помечаем все терминальные вершины, в данном случае — <tex>\{1, 2\}</tex>.
  
По нашему заданию эквивалентного ДКА мы получаем [[Файл:NKA_definition.jpg]].
+
В итоге получаем ДКА, эквивалентный исходному:  
  
#Поместим в очередь множество из одной стартовой вершины - <tex>\{1\}</tex>: <tex>Q = \{\{1\}\}</tex>
+
[[Файл:NKA_algorithm.png|250px]].
#Вытащили из очереди множество <tex>\{1\}</tex>
 
#<tex>q_d(\{1\}, a) = \{1, 2\}</tex>, положили множество <tex>\{1, 2\}</tex> в очередь: <tex>Q = \{\{1, 2\}\}</tex>
 
#<tex>q_d(\{1\}, b) = \{1\}</tex>, нам не надо класть множество <tex>\{1\}</tex> в очередь, т.к. оно уже там было
 
#Вытащили из очереди множество <tex>\{1, 2\}</tex>: <tex>Q = \{\}</tex>
 
#<tex>q_d(\{1, 2\}, a) = \{1, 2\}</tex>, нам не надо класть множество <tex>\{1, 2\}</tex> в очередь, т.к. оно уже там было
 
#<tex>q_d(\{1, 2\}, b) = \{1, 2\}</tex>, нам не надо класть множество <tex>\{1, 2\}</tex> в очередь, т.к. оно уже там было
 
  
А в итоге получили эквивалентный ДКА, чуть меньше: [[Файл:NKA_algorithm.jpg]].
+
== См. также ==
 +
 
 +
* [[Регулярные языки: два определения и их эквивалентность]]
 +
* [[Минимизация ДКА, алгоритм за O(n^2) с построением пар различимых состояний]]
 +
* [[Теорема Клини (совпадение классов автоматных и регулярных языков)]]
 +
 
 +
== Источники информации ==
 +
* ''Серебряков В.А.'' Теория и реализация языков программирования. М.: МЗ-Пресс, 2003 (1-е изд.) и 2006 (2-е изд) — С. 294. — ISBN 5-94073-094-9
 +
 
 +
[[Категория: Теория формальных языков]]
 +
[[Категория: Автоматы и регулярные языки]]

Текущая версия на 17:53, 16 мая 2018

Описание[править]

Алгоритм Томпсона строит по НКА эквивалентный ДКА следующим образом:

  • Начало.
  • Шаг 1. Помещаем в очередь [math]Q[/math] множество, состоящее только из стартовой вершины.
  • Шаг 2. Затем, пока очередь не пуста выполняем следующие действия:
    • Достаем из очереди множество, назовем его [math]q[/math]
    • Для всех [math]c \in \Sigma[/math] посмотрим в какое состояние ведет переход по символу [math]c[/math] из каждого состояния в [math]q[/math]. Полученное множество состояний положим в очередь [math]Q[/math] только если оно не лежало там раньше. Каждое такое множество в итоговом ДКА будет отдельной вершиной, в которую будут вести переходы по соответствующим символам.
    • Если в множестве [math]q[/math] хотя бы одна из вершин была терминальной в НКА, то соответствующая данному множеству вершина в ДКА также будет терминальной.
  • Конец.

Построение эквивалентного ДКА по НКА[править]

Пусть нам дан произвольный НКА: [math]\langle \Sigma , Q, s \in Q, T \subset Q, \delta : Q \times \Sigma \to 2^Q \rangle[/math].

Построим по нему следующий ДКА: [math]\langle \Sigma , Q_d, s_d \in Q_d, T_d \subset Q_d, \delta_d : Q_d \times \Sigma \to Q_d \rangle[/math], где:

  1. [math]Q_d = \{q_d \mid q_d \subset 2^Q \}[/math],
  2. [math]s_d = \{s\}[/math],
  3. [math]T_d = \{q \in Q_d \mid \exists p \in T : p \in q\}[/math],
  4. [math]\delta_d(q, c) = \{ \delta(a, c) \mid a \in q \}[/math].

Доказательство эквивалентности[править]

Теорема:
Построенный ДКА эквивалентен данному НКА.
Доказательство:
[math]\triangleright[/math]
  1. Докажем, что любое слово, которое принимает НКА, будет принято построенным ДКА. Заметим, что [math]\forall q \in q_d, \forall c \in \Sigma, \forall p \in \delta(q, c): p \in \delta_d(q_d, c)[/math]. Рассмотрим слово [math]w=w_1 \dots w_m[/math], которое принимает автомат НКА: [math]\langle s, w_1w_2 \dots w_m \rangle \vdash \langle u_1, w_2 \dots w_m \rangle \vdash \langle u_m, \varepsilon \rangle, u_m \in T[/math]. Проверим, что построенный ДКА тоже принимает это слово. Заметим, что [math]s \in s_d[/math], а, значит, исходя из нашего наблюдения, мы получаем, что [math]u_1 \in {u_d}_1[/math], где [math]{u_d}_1 = \delta_d(s, w_1)[/math]. Далее, несложно заметить, что [math]\forall i \leqslant m : u_i \in {u_d}_i[/math], где [math]\langle s_d, w_1w_2 \dots w_m \rangle \vdash \langle {u_d}_1, w_2 \dots w_m \rangle \vdash \langle {u_d}_i, w_{i + 1} \dots w_m\rangle[/math]. Таким образом, [math]u_m \in {u_d}_m[/math], а из определения терминальных состояний в построенном ДКА мы получаем, что [math]{u_d}_m \in T_d[/math], то есть наш ДКА тоже принимает cлово [math]w[/math].
  2. Докажем, что любое слово, которое принимает построенный ДКА, принимает и НКА. Сначала сделаем наблюдение, что если [math]q_d=\{q\}[/math], и мы из него достигли по строке [math]S[/math] какого-то состояния [math]p_d[/math], то [math]\forall p \in p_d[/math] существует путь из [math]q[/math] в [math]p[/math] в НКА по строке [math]S[/math]. Рассмотрим слово [math]w=w_1 \dots w_m[/math], которое принимает автомат ДКА: [math]\langle s_d, w_1w_2 \dots w_m \rangle \vdash \langle {u_d}_1, w_2 \dots w_m \rangle \vdash \langle {u_d}_m, \varepsilon \rangle, {u_d}_m \in T_d[/math]. Проверим, что НКА тоже принимает это слово. Так как [math]s_d = \{s\}[/math], и мы из [math]s_d[/math] достигли [math]{u_d}_m \in T_d[/math], возьмём любое терминальное состояние [math]u_m \in {u_d}_m[/math]. По нашему наблюдению в НКА есть путь из [math]s[/math] в [math]u_m[/math] по строке [math]w[/math], а, значит, НКА принимает это слово.
Таким образом, множества слов, допускаемых ДКА и НКА, совпадают, то есть они эквивалентны.
[math]\triangleleft[/math]

Алгоритм Томпсона[править]

Данный алгоритм преобразовывает НКА в эквивалентный ДКА. Будем использовать вышеуказанный способ построения с одним дополнением — не будем учитывать состояния недостижимые из стартового. Поэтому в алгоритме используется обход в ширину.

Алгоритм[править]

  • [math]\mathtt{P}[/math] — очередь состояний, соответствующих множествам, состоящих из состояний НКА.
  • [math]\mathtt{Q_d}[/math] — массив множеств, соответствующих состояниям ДКА.
  • [math]\mathtt{s}[/math] — стартовое состояние НКА.
Automaton getDFAbyNFA([math]\langle \Sigma, Q, s, T, \delta \rangle[/math] : Automaton):
   [math]P[/math].push([math]\{s\}[/math])
   [math]Q_d[/math] = [math]\varnothing[/math]
   while [math]P[/math] [math] \neq [/math] [math]\varnothing [/math]
      [math]P[/math].pop([math]p_d[/math])
      for [math]c \in \Sigma[/math]
         [math]q_d[/math] = [math]\varnothing[/math]
         for [math]p \in p_d[/math]
            [math]q_d[/math] = [math]q_d \cup \{ \delta(p, c) \}[/math]
         [math]\delta_d(p_d, q_d)[/math] = [math]c[/math]
         if [math]q_d \notin Q_d[/math]
            [math]P[/math].push([math]q_d[/math])
            [math]Q_d[/math].add([math]q_d[/math])           
   [math]T_d[/math] = [math]\{q_d \in Q_d \mid \exists p \in T : p \in q_d\}[/math]
   return [math]\langle \Sigma, Q_d, \{s\}, T_d, \delta_d \rangle[/math]

Асимптотика[править]

Так как количество подмножеств множества состояний НКА не более, чем [math]2^n[/math], а каждое подмножество мы обрабатываем ровно один раз за время [math]O(n)[/math], получаем верхнюю оценку времени работы алгоритма — [math]O(n \cdot 2^n)[/math].

Пример[править]

Пусть нам дан недетерминированный конечный автомат:

DKA.png

По нашему заданию эквивалентного ДКА мы получаем:

NKA definition.png

  1. Помещаем в очередь множество из одной стартовой вершины — [math]\{1\}[/math]: [math]Q = \{\{1\}\}[/math].
  2. Достаём из очереди множество [math]\{1\}[/math]: [math]Q = \{\}[/math].
  3. [math]q_d(\{1\}, a) = \{1, 2\}[/math], кладём множество [math]\{1, 2\}[/math] в очередь: [math]Q = \{\{1, 2\}\}[/math].
  4. [math]q_d(\{1\}, b) = \{1\}[/math], нам не надо класть множество [math]\{1\}[/math] в очередь, так как оно уже там было.
  5. Достаём из очереди множество [math]\{1, 2\}[/math]: [math]Q = \{\}[/math].
  6. [math]q_d(\{1, 2\}, a) = \{1, 2\}[/math], нам не надо класть множество [math]\{1, 2\}[/math] в очередь, так как оно уже там было.
  7. [math]q_d(\{1, 2\}, b) = \{1, 2\}[/math], нам не надо класть множество [math]\{1, 2\}[/math] в очередь, так как оно уже там было.
  8. Помечаем все терминальные вершины, в данном случае — [math]\{1, 2\}[/math].

В итоге получаем ДКА, эквивалентный исходному:

NKA algorithm.png.

См. также[править]

Источники информации[править]

  • Серебряков В.А. Теория и реализация языков программирования. М.: МЗ-Пресс, 2003 (1-е изд.) и 2006 (2-е изд) — С. 294. — ISBN 5-94073-094-9