Классы L, NL, coNL. NL-полнота задачи о достижимости — различия между версиями

Материал из Викиконспекты
Перейти к: навигация, поиск
Строка 1: Строка 1:
 +
{| class="wikitable" align="center" style="color: red; background-color: black; font-size: 56px; width: 800px;"
 +
|+
 +
|-align="center"
 +
|'''НЕТ ВОЙНЕ'''
 +
|-style="font-size: 16px;"
 +
|
 +
24 февраля 2022 года российское руководство во главе с Владимиром Путиным развязало агрессивную войну против Украины. В глазах всего мира это военное преступление совершено от лица всей страны, всех россиян.
 +
 +
Будучи гражданами Российской Федерации, мы против своей воли оказались ответственными за нарушение международного права, военное вторжение и массовую гибель людей. Чудовищность совершенного преступления не оставляет возможности промолчать или ограничиться пассивным несогласием.
 +
 +
Мы убеждены в абсолютной ценности человеческой жизни, в незыблемости прав и свобод личности. Режим Путина — угроза этим ценностям. Наша задача — обьединить все силы для сопротивления ей.
 +
 +
Эту войну начали не россияне, а обезумевший диктатор. И наш гражданский долг — сделать всё, чтобы её остановить.
 +
 +
''Антивоенный комитет России''
 +
|-style="font-size: 16px;"
 +
|Распространяйте правду о текущих событиях, оберегайте от пропаганды своих друзей и близких. Изменение общественного восприятия войны - ключ к её завершению.
 +
|-style="font-size: 16px;"
 +
|[https://meduza.io/ meduza.io], [https://www.youtube.com/c/popularpolitics/videos Популярная политика], [https://novayagazeta.ru/ Новая газета], [https://zona.media/ zona.media], [https://www.youtube.com/c/MackNack/videos Майкл Наки].
 +
|}
 +
 
{{Определение
 
{{Определение
 
|definition='''Класс <tex>\mathrm{L}</tex>''' — множество языков, разрешимых на детерминированной машине Тьюринга с использованием <tex>O(\log n)</tex> дополнительной памяти для входа длиной <tex>n</tex>.
 
|definition='''Класс <tex>\mathrm{L}</tex>''' — множество языков, разрешимых на детерминированной машине Тьюринга с использованием <tex>O(\log n)</tex> дополнительной памяти для входа длиной <tex>n</tex>.

Версия 08:56, 1 сентября 2022

НЕТ ВОЙНЕ

24 февраля 2022 года российское руководство во главе с Владимиром Путиным развязало агрессивную войну против Украины. В глазах всего мира это военное преступление совершено от лица всей страны, всех россиян.

Будучи гражданами Российской Федерации, мы против своей воли оказались ответственными за нарушение международного права, военное вторжение и массовую гибель людей. Чудовищность совершенного преступления не оставляет возможности промолчать или ограничиться пассивным несогласием.

Мы убеждены в абсолютной ценности человеческой жизни, в незыблемости прав и свобод личности. Режим Путина — угроза этим ценностям. Наша задача — обьединить все силы для сопротивления ей.

Эту войну начали не россияне, а обезумевший диктатор. И наш гражданский долг — сделать всё, чтобы её остановить.

Антивоенный комитет России

Распространяйте правду о текущих событиях, оберегайте от пропаганды своих друзей и близких. Изменение общественного восприятия войны - ключ к её завершению.
meduza.io, Популярная политика, Новая газета, zona.media, Майкл Наки.


Определение:
Класс [math]\mathrm{L}[/math] — множество языков, разрешимых на детерминированной машине Тьюринга с использованием [math]O(\log n)[/math] дополнительной памяти для входа длиной [math]n[/math]. [math]\mathrm{L} = \mathrm{DSPACE}(\log n)[/math].


Определение:
Класс [math]\mathrm{NL}[/math] — множество языков, разрешимых на недетерминированной машине Тьюринга с использованием [math]O(\log n)[/math] дополнительной памяти для входа длиной [math]n[/math]. [math]\mathrm{NL} = \mathrm{NSPACE}(\log n)[/math].


Теорема:
[math]\mathrm{L} \subset \mathrm{NL} \subset \mathrm{P}.[/math]
Доказательство:
[math]\triangleright[/math]
  1. Детерминированная машина Тьюринга есть частный случай недетерминированной, поэтому [math]\mathrm{L} \subset \mathrm{NL}[/math].
  2. Число конфигураций машины, использующей [math]O(\log n)[/math] памяти не превышает [math]2^{O(\log n)} = n^{O(1)} = poly(n)[/math], а, следовательно, если машина завершает свою работу, то она это делает за [math]O(poly(n))[/math] времени. Следовательно, [math]\mathrm{NL} \subset \mathrm{P}.[/math]
[math]\triangleleft[/math]

NL-полнота

Определение:
Задача [math]\mathrm{CONN} = \{\langle G, s, t \rangle \bigm|[/math] в графе G есть путь из s в t[math]\}[/math] — задача существования пути между двумя заданными вершинами в данном графе.


Теорема:
Задача существования пути между двумя заданными вершинами в данном графе NL-полна относительно [math]\mathrm{\widetilde{L}}[/math]-сведения.
Доказательство:
[math]\triangleright[/math]

Докажем, что [math]\mathrm{CONN} \in \mathrm{NL}[/math]. Для доказательства необходимо предъявить алгоритм для недетерминированной машины Тьюринга, который использует конечное число переменных, каждая из которых занимает [math] O(\log n) [/math] памяти, где [math] n [/math] — размер входа, и за время порядка [math] O(poly(n)) [/math] решает эту задачу.

Алгоритм:

  1. Начиная с вершины [math] s [/math] недетерминированно переходим в одну из вершин, смежных с ней. (Очевидно, для этого необходимо конечное число переменных).
  2. Проверяем, правда ли, что текущая вершина совпадает с [math] t [/math]. Если это так, возвращает TRUE.
  3. Отдельно считаем количество пройденных вершин. Как только это число превышает количество вершин в графе, возвращаем FALSE, так как посетили некоторую вершину дважды.

Таким образом в каждый момент алгоритму достаточно хранить текущую вершину, количество посещенных вершин, финальную вершину [math] t [/math] и некоторое число вспомогательных переменных, для совершения переходов. Все эти переменные принимают значения не более, чем максимальный номер вершины, то есть как раз занимают [math] O(\log n) [/math] памяти.

Теперь докажем, что любая задача из класса [math]\mathrm{NL}[/math] сводится к задаче [math]\mathrm{CONN}[/math] с использованием не более чем логарифмической памяти.

Необходимо по данной задаче из [math]\mathrm{NL}[/math] построить тройку [math] \langle G, s, t \rangle [/math], решение задачи [math]\mathrm{CONN}[/math] для которой будет эквивалентно решению данной задачи.

Любая машина Тьюринга, которая принимает некоторый язык [math]L[/math] из [math]\mathrm{NL}[/math], использует не более чем логарифмическое количество ячеек на рабочей ленте, и таким образом возможных мгновенных описаний этой машины Тьюринга [math] O(poly(n)) [/math]. Каждому возможному мгновенному описанию машины Тьюринга будет соответствовать некоторая вершина в [math] G [/math], а каждому переходу из этого описания в другое (которых в недетерминированной машине Тьюринга конечное число) — ребро в графе [math] G [/math]. За вершину [math] s [/math] принимается вершина, соответствующая начальному состоянию машины, а из каждой вершины, соответствующей некоторому допускающему состоянию, добавляется переход в выделенную вершину [math] t [/math].

Очевидно, что для любого слова из языка [math]L[/math], то есть принимаемого данной машиной Тьюринга, будет существовать путь из [math] s [/math] в [math] t [/math] в построенном графе [math] G [/math]. А если для некоторого слова не из [math]L[/math] в [math] G [/math] существует путь из [math] s [/math] в [math] t [/math], то он соответствует некоторой корректной последовательности переходов в изначальной машине, таким образом слово должно было приниматься этой недетерминированной машиной.

Такое построение графа [math] G [/math] по данной машине Тьюринга можно выполнить с использованием конечного числа переменных, которые будут перебирать всевозможные мгновенные состояния машины (их [math] O(poly(n)) [/math], потому переменная, перебирающая его занимает [math] O(\log n) [/math] памяти), переходов из него и проверки возможности перехода.
[math]\triangleleft[/math]

Теорема Иммермана

Определение:
Задача несуществования пути между двумя заданными вершинами в данном графе [math]\mathrm{NCONN} = \{\langle G, s, t \rangle \bigm|[/math] в графе G нет пути из s в t[math]\}.[/math]


Теорема:
[math]\mathrm{coNL} = \mathrm{NL}.[/math]
Доказательство:
[math]\triangleright[/math]

Очевидно, что язык [math]\mathrm{NCONN}[/math] является дополнением языка [math]\mathrm{CONN}[/math]. Чтобы показать, что [math]\mathrm{NCONN}\in \mathrm{NL}[/math], придумаем недетерминированый алгоритм, использующий [math]O(\log |G|)[/math] памяти, который проверяет, достижима ли вершина [math]t[/math] из [math]s[/math].

Определим [math]R_i[/math] = {[math]v \bigm|[/math] существует путь из [math]s[/math] в [math]v[/math] длиной [math]\leq i[/math]}. Другими словами это множество всех вершин, достижимых из [math]s[/math] не более чем за [math]i[/math] шагов.

Введем обозначение [math]r_i=|R_i|[/math]. Если [math]t \notin R_{n-1}[/math], где [math]n = |V|[/math], то не существует путь из [math]s[/math] в [math]t[/math] в графе [math]G[/math], то есть [math]\langle G, s, t \rangle \in \mathrm{NCONN}[/math]. Можно построить недетерминированный алгоритм, который будет допускать [math]r_i[/math] (то есть определять, существует ли путь из [math]s[/math] в [math]t[/math] такой длины) и при этом будет перечислять все вершины из [math]R_i[/math] на [math]O(\log |G|)[/math] памяти (это будет доказано ниже).

Таким образом показано, что [math]\mathrm{NCONN} \in \mathrm{NL}[/math]. Поскольку [math]\mathrm{CONN} \in \mathrm{NLC}[/math], то аналогичным образом [math]\mathrm{NCONN} \in \mathrm{coNLC}[/math]. Получаем, что любую задачу из [math]\mathrm{coNL}[/math] можно свести к задаче из [math]\mathrm{NL}[/math], а значит [math]\mathrm{coNL} \subset \mathrm{NL}[/math].

Из соображений симметрии [math]\mathrm{NL} \subset \mathrm{coNL}[/math], а значит [math]\mathrm{coNL} = \mathrm{NL}[/math].
[math]\triangleleft[/math]
Лемма:
Можно построить недетерминированный алгоритм, который будет допускать [math]r_i[/math] и при этом будет перечислять все вершины из [math]R_i[/math] на [math]O(\log |G|)[/math] памяти.
Доказательство:
[math]\triangleright[/math]

Можно построить недетерминированный алгоритм, который будет допускать [math]r_i[/math] и при этом будет перечислять все вершины из [math]R_i[/math] на [math]O(\log |G|)[/math] памяти.

 Enum([math]s, i, r_i, G[/math])
   [math]counter[/math] [math]\leftarrow[/math] 0                 //количество уже найденных и выведенных элементов
   for [math]v = 1..n[/math] do               //перебираем все вершины графа
     continue or find path      //недетерминированно угадываем путь из s до v или переходим к следующей вершине
     [math]counter[/math]++
     return [math]v[/math]                   //выдаем вершину, до которой угадали путь
   if ([math]counter \geq r_i[/math])             //нашли [math]r_i[/math] вершин, допускаем, завершаем работу
     accept
   reject                       //не нашли [math]r_i[/math] вершин, не допускаем
   

Enum перебирает все вершины на логарифмической памяти и пытается угадать путь до этой вершины из [math]s[/math]. Под угадыванием пути подразумевается последовательность недетерминированных выборов следующей вершины пути из [math]s[/math] в [math]v[/math]. Для угадывания пути необходимо [math]O(\log |G|)[/math] памяти, так как необходимо лишь хранить текущую и следующую угадываемую вершины угадываемого пути. Enum является недетерминированым алгоритмом, и если существует порядок его исполнения достигающий accept, то происходит допуск.

Теперь, имея Enum, можно по индукции находить [math]r_i[/math]. Очевидно, что [math]r_0 = 1[/math], так как [math]R_0[/math] содержит единственную вершину — [math]s[/math]. Пусть известно значение [math]r_i[/math]. Напишем программу, которая на логарифмической памяти будет находить [math]r_{i + 1}[/math].


 Next([math]s, i, r_i, G[/math])
   [math]r = 1[/math]                           //[math]r_{i+1}[/math] хотя бы один, так как [math]s \in R_{i+1}[/math]
   for [math]v = 1..n[/math]; [math]v \ne s[/math] do           //перебираем все вершины графа, кроме [math]s[/math] — это кандидаты на попадание в [math]R_{i+1}[/math]
     for [math]u : (u, v) \in E[/math] do           //перебираем все ребра, входящие в [math]v[/math]
       if ([math]u[/math] in Enum([math]s, i, r_i, G[/math]))    //перечисляем все вершины из [math]R_i[/math], если [math]u[/math] одна из них, то [math]v \in R_{i+1}[/math]
         [math]r[/math]++                       //увеличиваем количество найденных вершин и переходим к рассмотрению следующего кандидата
         break 
   return [math]r[/math]


Данный алгоритм изначально учитывает [math]s[/math], а затем перебирает всех возможных кандидатов [math]v[/math] на попадание в [math]R_{i + 1}[/math]. Для каждого из них перебираются все ребра, в него входящие. Затем перечисляются все вершины из [math]R_i[/math] и, если начало нашего ребра было перечислено, то [math]v \in R_{i + 1}[/math]. Алгоритм использует [math]O(\log |G|)[/math] памяти, так необходимо хранить лишь [math]v[/math], [math]u[/math], [math]r[/math] и еще поочередно значения полученные в результате вызова Enum.

Теперь напишем алгоритм, который будет недетерминированно решать задачу [math]\mathrm{NCONN}[/math] на логарифмической памяти. Он будет состоять из двух частей: вычисление [math]r_{n-1}[/math] и перечисление всех вершин из [math]R_{n - 1}[/math]. Вычисление [math]r_{n-1}[/math] происходит путем вызова Next [math]n - 1[/math] раз, при этом каждый раз в качестве [math]r_i[/math] подставляется новое полученное значение.


 NCONN([math]G, s, t[/math])
   [math]r_n = 1[/math]                          //[math]r_0 = 1[/math]
   for [math]i = 0..n - 2[/math] do               //вычисляем [math]r_{n-1}[/math]
     [math]r_n = [/math] Next([math]s, i, r_n, G[/math])
   if ([math]t1[/math] in Enum([math]s, n - 1, r_n, G[/math]))   //перечисляем вершины из [math]R_{n-1}[/math], если [math]t[/math] была перечислена, то [math]t[/math] достижима и выдаем reject, иначе accept
     reject
   else
     accept
Данный алгоритм использует [math]O(\log |G|)[/math] памяти, так как для хранения [math]r_n[/math] и [math]i[/math] необходимо [math]O(\log |G|)[/math], и для вызываемых Next и Enum необходимо [math]O(\log |G|)[/math] памяти.
[math]\triangleleft[/math]