Викиконспекты - Вклад участника [ru]

Сопряжённый оператор

2015-06-25T10:01:35Z

194.85.160.130: /* Теорема 2 */

{{В разработке}}

[[Спектр линейного оператора|<<]][[Компактный оператор |>>]]

Все рассматриваемые далее пространства считаем Банаховыми.

{{Определение
|definition=
<tex> E^* </tex> {{---}} множество линейных непрерывных функционалов над <tex> E </tex>, его называют пространством, сопряженным к <tex> E </tex>. 
Аналогично, <tex> E^{**} </tex> {{---}} пространство, сопряженное к <tex> E^* </tex>.
}}

== Естественное вложение ==
{{Утверждение
|statement=
Между <tex> E </tex> и <tex> E^{**} </tex> существует так называемый '''естественный изоморфизм''', сохраняющий норму точки.
|proof=
Введем <tex> F_x </tex> следующим образом: <tex>\forall x \in E : F_x (f) = f(x), f \in E^{*} </tex>.

<tex> F_x : E^{*} \to \mathbb{R} </tex> — функционал, заданный на <tex>E^{*}</tex>, то есть <tex> F_x \in E^{**} </tex>.

Тогда само <tex> F </tex> отображает <tex> E </tex> в <tex> E^{**} </tex>.

<tex> F </tex> линейно: <tex> F_{\alpha x_1 + \beta x_2} = \alpha F_{x_1} + \beta F_{x_2} </tex>.

<tex> | F_x(f) | = |f(x)| \le \| f \| \| x \| </tex>, откуда <tex> \| F_x \| \le \| x \| </tex>.

С другой стороны, по следствию из теоремы Хана-Банаха, для любого <tex> x_0 \in E </tex> существует <tex> f_0 \in E^* </tex>, такое, что выполняются два условия:
# <tex> f_0(x_0) = \| x_0 \| </tex>
# <tex> \| f_0 \| = 1 </tex>.

<tex> | F_{x_0} (f_0) | = f_0 (x_0) = \| x_0 \|, \| f_0 \| = 1 </tex>, потому получаем, что <tex> \| F_{x_0} \| \ge \| x_0 \| \implies \| F_{x_0} \| = \| x_0 \| </tex>.

Значит, получившееся преобразование <tex> x \mapsto F_x </tex> — изометрия, <tex> \| x \| = \| F_x \| </tex>, получили '''естественное вложение''' <tex> E </tex> в <tex> E^{**} </tex>.
}}

{{Определение
|definition=
<tex> E </tex> называется '''рефлексивным''', если <tex> E </tex> будет совпадать с <tex> E^{**} </tex> при таком отображении.
}}

Например, гильбертово пространство <tex> H </tex> рефлексивно (следует из теоремы Рисса об общем виде линейного функционала).

<tex> C[0, 1] </tex> не является рефлексивным.

== Сопряженный оператор ==

Пусть оператор <tex> A </tex> действует из <tex> E </tex> в <tex> F </tex>, и функционал <tex> \varphi </tex> принадлежит <tex> F^* </tex>.

Рассмотрим <tex> f(x) = \varphi (Ax), | f(x) | \le \| \varphi \| \| A \| \| x \| </tex>.

Получили новый функционал <tex> f </tex>, принадлежащий <tex> E^* </tex>. <tex> \varphi \mapsto \varphi A </tex>.

<tex> \varphi A = A^* (\varphi), A^* : F^* \to E^* </tex>. <tex> A^* </tex> {{---}} '''сопряженный оператор''' к <tex> A </tex>.

{{Теорема
|statement=
Если <tex> A </tex> {{---}} линейный ограниченный оператор, то <tex> \| A^* \| = \| A \| </tex>.
|proof=
Возьмем <tex> x \in E, \varphi \in F^* </tex>.

<tex> | A^* (\varphi, x) | = | \varphi (Ax) | \le \| A \| \| \varphi \| \| x \| </tex>.

Получили, что <tex> \| A^* (\varphi) \| \le \| A \| \| \varphi \| </tex>, откуда <tex> \| A^* \| \le \| A \| </tex>.

Для доказательства в обратную сторону используем [[Теорема Хана-Банаха#hbnorm|следствие из теоремы Хана-Банаха]]:

По определению нормы оператора: <tex> \forall \varepsilon > 0 \, \exists x: \| x \| = 1 \implies \| A \| - \varepsilon < \| Ax \| </tex>.

<tex> Ax \in F </tex>, по следствию из теоремы Хана-Банаха подберем <tex> \varphi_0 \in F^*, \| \varphi_0 \| = 1: \varphi_0 (Ax) = \| Ax \| </tex>.

<tex> | A^*(\varphi_0, x) | = | \varphi_0(Ax) | = \| Ax \| > \| A \| - \varepsilon </tex>.

<tex> | A^*(\varphi_0, x) | \le \| A^*(\varphi_0) \| \| x \| = \| A^*(\varphi_0) \| \le \| A^* \| \| \varphi_0 \| = \| A^* \| </tex>.

Соединяя эти два неравенства, получаем, что <tex> \forall \varepsilon > 0: \| A^* \| > \| A \| - \varepsilon </tex>.

Устремляя <tex> \varepsilon </tex> к нулю, получаем, что <tex> \| A^* \| \ge \| A \| </tex>, и, окончательно, <tex> \| A^* \| = \| A \| </tex>.

}}

== Примеры сопряженных операторов ==

Возьмем любое гильбертово пространство <tex> H </tex>, <tex> A : H \to H </tex>.

<tex> \forall \varphi \in H^* </tex> по теореме Рисса об общем виде линейного функционала в <tex> H </tex> существует единственный
<tex> z : \varphi (y) = \langle y, z \rangle, \| \varphi \| = \| z \| </tex>.

Поскольку <tex> x \mapsto \varphi (Ax) </tex> также является линейным функционалом <tex> H \to H </tex>, то <tex> \varphi (Ax) = \langle Ax, z \rangle = \langle x, y \rangle </tex>, где <tex> y </tex> не зависит от <tex> x </tex>.

Имеем отображение <tex> z \mapsto y </tex>, тогда <tex> y = A^*(z) </tex>, и окончательно:

<tex> \langle Ax, z \rangle = \langle x, A^*z \rangle </tex>.

В гильбертовом пространстве <tex> H </tex> сопряженный оператор {{---}} тот оператор, который позволяет писать равенство выше.

{{Определение
|definition=
Оператор <tex> A </tex> в гильбертовом пространстве называется '''самосопряженным''', если <tex> A = A^* </tex>
}}

В случае <tex> \mathbb{R}^n </tex> (частный случай <tex> H </tex>) оператор <tex> A : \mathbb{R}^n \to \mathbb{R}^n </tex> представляет собой матрицу размером <tex> n \times n </tex>. Сопряженный к <tex> A </tex> оператор получается транспонированием соответствующей матрицы: <tex> A^* = A^T </tex>. Для симметричной матрицы <tex> A </tex> получается <tex> A^* = A^T = A </tex>, то есть, если <tex> A </tex> {{---}} симметричная матрица, то <tex> A </tex> {{---}} самосопряженный оператор.

Рассмотрим теперь пространство <tex> E = L_p [0, 1] </tex>.

Пусть <tex> K(u, v) : [0, 1] \times [0, 1] \to \mathbb{R} </tex> {{---}} непрерывная функция на <tex> [0, 1] \times [0, 1] </tex>, <tex> x \in E </tex>.

'''Интегральный оператор''' <tex> A </tex>, действующий из <tex> L_p [0, 1] </tex> в <tex> L_p [0, 1] </tex> определяется так: <tex> A(x, s) = (Ax)(s) = \int\limits_0^1 K(s, t) x(t) dt </tex>. <tex> Ax \in E </tex>.

Построим сопряженный оператор:

По теореме об общем виде линейного функционала в <tex> L_p </tex>,

<tex> \forall \varphi \in E^*, x \in E: \varphi(x) = \int\limits_0^1 y(t) x(t) dt, y \in L_q </tex>, где <tex> \frac 1p + \frac 1q = 1 </tex> (<tex> p </tex> и <tex> q </tex> называются '''сопряженными показателями''').

<tex> L_p^* = L_q </tex>.

<tex> A^*(\varphi, x) = \varphi (Ax) = \int\limits_0^1 y(s) (Ax)(s) ds = \int\limits_0^1 y(s) (\int\limits_0^1 K(s, t) x(t) dt) ds = </tex> (по теореме Фубини поменяем порядок интегрирования) <tex> = \int\limits_0^1 ( \int\limits_0^1 K(s, t) y(s) ds) x(t) dt </tex>

Получили, что <tex> A^*(\varphi, x) = \int\limits_0^1 ( \int\limits_0^1 K(s, t) y(s) ds) x(t) dt </tex>. Обозначим <tex> z(t) = \int\limits_0^1 K(s, t) y(s) ds </tex>, тогда <tex> A^* (\varphi) \equiv z </tex>, аналогично <tex> \varphi \equiv y </tex>.

<tex> A^* </tex> {{---}} интегральный оператор из <tex> L_q </tex>, имеющий ядро <tex> K^*(s, t) = K(t, s) </tex>. В частности, если ядро симметрично (<tex> K(s, t) = K(t, s) </tex>) и <tex> p = q = 2 </tex>, то <tex> A = A^* </tex>.

== Ортогональное дополнение ==

Важное значение имеет ортогональное дополнение (в любом нормированном пространстве):

{{Определение
|definition=
Пусть <tex> E </tex> {{---}} НП, <tex> S \subset E^* </tex>.

<tex> S^{\bot} = \{ x \in E \mid \forall f \in S: f(x) = 0 \} </tex> {{---}} '''ортогональное дополнение''' <tex> S </tex>.

Аналогично, если <tex> T \subset E </tex>, то <tex> T^{\bot} = \{ f \in E^* \mid \forall x \in T: f(x) = 0 \} </tex>.
}}

{{Утверждение
|statement= <tex> \{ 0 \} = (E^*)^{\bot}, \{ \mathbf{0} \} = E^{\bot} </tex>.
|proof=

Оба включения <tex> \subset </tex> очевидны по определению. В обратную сторону:

# Пусть <tex> x \in (E^*)^{\bot} </tex>, тогда <tex> \forall f \in E^*: f(x) = 0 </tex>. Предположим, что <tex> x \neq 0 </tex>, тогда по [[Теорема Хана-Банаха|следствию из теоремы Хана-Банаха]], для такого <tex>x</tex>, найдется функционал <tex>f: f(x) = \| x \| \neq 0 </tex>, получили противоречие, что <tex> x \in (E^*)^{\bot} </tex>.
# Пусть <tex> f \in E^\bot </tex>, тогда <tex> \forall x \in E: f(x) = 0</tex>. Тогда <tex>f</tex> — нулевой функционал по определению.
}}

== Теоремы о множестве значений оператора ==
=== Теорема 1 ===

{{Теорема
|statement= <tex> A \in \mathcal{L}(E,F) \implies \operatorname{Cl} R(A) = (\operatorname{Ker} A^*)^\perp </tex>.
|proof =
<tex>\subset</tex>:

<tex>\forall \varphi \in \operatorname{Ker}A^*</tex>, <tex>A^* \varphi = \mathbf{0}</tex>.

Пусть <tex>y \in R(A) </tex>, тогда <tex> y = Ax </tex>.

<tex> \varphi (y) = \varphi(A x) = A^*(\varphi, x) = 0 </tex>, следовательно, <tex> R(A)\subset(\operatorname{Ker}A^*)^\perp</tex>.

Теперь, пусть <tex>y \in \operatorname{Cl} R(A)</tex>, тогда <tex> y = \lim y_n, y_n \in R(A)</tex>.

<tex>\varphi(y_n) = 0, \varphi(y_n) \xrightarrow[]{n \to \infty} \varphi(y) \implies \varphi(y) = 0</tex>, и <tex>\operatorname{Cl}(R(A)) \subset (\operatorname{Ker}(A^*))^\perp</tex>

<tex>\supset</tex>:

Надо показать, что <tex>y \in (\operatorname{Ker}A^*)^\perp \implies y \in \operatorname{Cl} R(A)</tex>. Пусть это не так: <tex> y \notin \operatorname{Cl} R(A)</tex>.

Рассмотрим <tex> F_1 = \left\{ z + ty \mid z \in \operatorname{Cl}(R(A)), y \notin \operatorname{Cl}(R(A)), t \in \mathbb{R} \right\} </tex>. <tex>F_1</tex> {{---}} линейное множество в силу линейности <tex>\operatorname{Cl}(R(A))</tex>.

Покажем, что <tex>F_1</tex> -- подпространство <tex>F</tex>. Для этого нам осталось проверить замкнутость <tex>F_1</tex>:

Пусть <tex>z_n+t_{n}y \to u = z + ty</tex>, хотим убедиться в том, что <tex>u \in F_1</tex>.

Если <tex> |t_{n}| \le const </tex>, то выберем <tex>t_{n_k}</tex>, стремящееся к какому-то <tex>t</tex>. Из <tex>z_n+t_{n}y \to u, t_{n_k}y \to ty </tex> получаем <tex> z_n \to z \in \operatorname{Cl}(R(A))</tex>.

Если допустить, что <tex>t_{n_k} \to \infty</tex>:

<tex>z_{n_k}+t_{n_k}y \to u</tex>. <tex>z_{n_k}/t_{n_k} + y \to 0 \implies z_{n_k}/t_{n_k} \to -y \implies -y \in \operatorname{Cl}(R(A)) \implies y \in \operatorname{Cl}(R(A))</tex> {{---}} противоречие.

Таким образом, <tex>\operatorname{Cl}(F_1) = F_1</tex>.

Построим на <tex>F_1</tex> фунционал <tex>\varphi_0 : \varphi_0(z+ty) = t </tex>, <tex> \varphi_0(z) = 0</tex>. Он, очевидно, непрерывен, а по теореме Хана-Банаха с сохранением непрерывности его можно продолжить на <tex>F: \widetilde{\varphi_0} \in F^*</tex>, причем так, что <tex>\widetilde{\varphi_0}\mid _{F_1} = \varphi_0</tex>.

Рассмотрим значение <tex>\widetilde{\varphi_0}(y)</tex>:

* С одной стороны, <tex>\widetilde{\varphi_0}(y) = \varphi_0(y) = \varphi_0(0 + 1 y) = 1</tex>
* С другой стороны, <tex>y \in (\operatorname{Ker}A^*)^\perp</tex>, а значит, на любом функционале из ядра <tex>A^*</tex>, в том числе, и на <tex>\widetilde{\varphi_0}</tex>, должно выполняться <tex>\widetilde{\varphi_0}(y) = 0</tex>

Получили противоречие, следовательно, <tex> y \in \operatorname{Cl}(R(A))</tex>.
}}

=== Теорема 2 ===

{{Теорема
|statement= <tex> A \in \mathcal{L}(E,F),~R(A) = \operatorname{Cl} R(A) \implies R(A^*) = (\operatorname{Ker}A )^\perp </tex>.
|proof =
1) <tex>f \in R(A^*) \implies f = \varphi A , \varphi \in F^*</tex>.

Рассмотрим <tex> x \in (\operatorname{Ker}A). </tex>
<tex>f(x) = \varphi(Ax) = \varphi(0) = 0 \implies R(A^*) \subset (\operatorname{Ker}A )^\perp</tex>.

2) Докажем теперь обратное включение:

<tex>(\operatorname{Ker}A )^\perp</tex> — набор таких <tex>f</tex>, что если <tex>Ax=0</tex>, то <tex>f(x)=0</tex>.

Надо показать, что <tex>f \in R(A^*)</tex>, т.е. проверить, что <tex>f = A^* \varphi = \varphi A</tex>.

Если найдем <tex>\varphi</tex>, заданный на <tex>R(A)</tex>, то сможем продолжить его на все <tex>F</tex> по теореме Хана-Банаха.

Рассмотрим произвольное <tex>y \in R(A)</tex>, пусть <tex>y = Ax</tex> и <tex>y = Ax'</tex>.

Тогда <tex>A(x - x') = 0</tex>, то есть <tex>x - x' \in \operatorname{Ker} A</tex>, <tex>f(x - x') = 0</tex>, и <tex>f(x) = f(x')</tex>, то есть, значение функционала не зависит от того, какой конкретно <tex>x</tex> (при <tex>Ax = y</tex>) был выбран.

Тогда можно взять <tex>\varphi(y) = f(x)</tex>, где <tex>y = Ax</tex> — линейный функционал, <tex>f = \varphi A</tex>. Осталось проверить ограниченность <tex>\varphi</tex> на <tex>R(A)</tex>.

Рассмотрим <tex>E/_{\operatorname{Ker} A}</tex>, <tex>\widetilde{A} : E/_{\operatorname{Ker} A} \to F</tex>, <tex>\widetilde{A}([x]) = Ax</tex>.

<tex>\widetilde{A} : E/_{\operatorname{Ker} A} \to R(A)</tex> — биекция, <tex>R(A)</tex> — замкнуто, <tex>F</tex> — банахово, поэтому <tex>R(A)</tex> — также банахово как подпространство в <tex>F</tex>. Введем норму для <tex>[x] \in E/_{\operatorname{Ker} A}</tex> как <tex>\|[x]\| = \inf\limits_{x\in [x]} \|x\|</tex>.

Покажем, что <tex>\widetilde{A}</tex> — ограничен: <tex>\|\widetilde{A}\| = \sup\limits_{\|[x]\| = 1} \|\widetilde{A}[x]\|</tex>. Для этого перейдем от классов эквивалентности к их представителям. Так как <tex>\|[x]\| = \inf\limits_{x \in [x]} \|x\| = 1</tex>, найдется <tex>x \in [x]</tex>, такой, что <tex>\|x\| \le 2</tex> (по определению инфимума), возьмем его в качестве представителя (мы можем это сделать, так как значение <tex>Ax</tex> одно и тоже для любого <tex>x\in[x]</tex>). Тогда: <tex>\|\widetilde{A}\| = \sup\limits_{\|[x]\| = 1} \|\widetilde{A}[x]\| \le \sup\limits_{\|x\| \le 2} \|Ax\| \le \sup\limits_{\|y\| \le 1} \|A(2 y)\| \le 2 \sup\limits_{\|y\| \le 1} \|Ay\| = 2 \|A\|</tex>, так как <tex>\|A\|</tex> был ограничен, <tex>\widetilde{A}</tex> тоже окажется ограниченным.

Тогда по [[Теорема Банаха об обратном операторе#Теорема Банаха о гомеоморфизме|теореме Банаха об гомеоморфизме]] существует линейный ограниченный оператор <tex>\widetilde{A}^{-1}</tex>, <tex>\| \widetilde{A}^{-1}(y) \| \le m \|y\| < 2m \|y\|</tex>. Замечание: строгое неравенство нам нужно для того, чтобы обеспечить существование такого <tex> x' \in A^{-1}(y) </tex>, что <tex> \| x' \| < 2m\| y \| </tex>.

<tex>\widetilde{A}^{-1}(y) = \{ x: y = Ax \}</tex>

<tex>\|\widetilde{A}^{-1}(y)\| = \inf\limits_{x\in \widetilde{A}^{-1}(y)} \|x\| < 2m \|y\| </tex>, следовательно, существует <tex> x' = A^{-1}y, \|x'\| < 2m\|y\|</tex>.

<tex> \|\varphi(y)\| = \|f(x')\| \le \|f\|\|x'\| < (2m\|f\|)\|y\| </tex>, то есть, получили ограниченность <tex> \varphi </tex>, теорема доказана.
}}

Эти две теоремы являются наиболее общей формой записи условий разрешимости операторных уравнений.

Смысл: рассмотрим уравнение <tex>Ax = y</tex>, где <tex>y</tex> — дано. Для того, чтобы понять, разрешимо ли уравнение, нужно проверить, что <tex>y \in R(A)</tex>. В общем случае, не существует способа это сделать, но можно ограничиться проверкой <tex>R(A) = \operatorname{Cl} R(A)</tex>, и тогда <tex>R(A) = (\operatorname{Ker}A^*)^\bot</tex>, сопряженный оператор можно построить, ядро поддается конструктивному описанию: <tex>y \in R(A) \iff y \perp \operatorname{Ker} A^*</tex>.

Например, <tex>A: \mathbb{R}^m \to \mathbb{R}^n</tex>, <tex>A^* = A^\top : \mathbb{R}^n \to \mathbb{R}^m</tex>. <tex>R(A) = \operatorname{Cl} R(A)</tex>, <tex>Ax = y</tex>, <tex>y</tex> — дано. Надо смотреть <tex>y \perp \operatorname{Ker} A^*</tex>, то есть <tex>A^\top y = 0</tex>.

В следующих параграфах мы введем класс бесконечномерных операторов, для которых <tex>R(A)</tex> — замкнуто, в частности, в этот класс входят интегральные операторы.

[[Категория: Функциональный анализ 3 курс]]

Поисковые структуры данных

2015-05-25T12:26:47Z

194.85.160.130:

'''Поисковая структура данных''' {{---}} любая структура данных реализующая эффективный поиск конкретных элементов множества, например, конкретной записи в базе данных.

Простейший, наиболее общий, но менее эффективный поисковой структурой является простая неупорядоченный последовательная всех элементов. Расположив элементы в такой список, неизбежно возникнет ряд операций, которые потребуют линейного времени, в худшем случае, а также в средней случае. Используемые в реальной жизни поисковые структуры данных позволяют совершать операции более быстро, однако они ограничены запросами некоторого конкретного вида. Кроме того, поскольку стоимость построение таких структур пропорциональна <tex>n</tex>, их построение окупится, даже если поступает лишь несколько запросов.

=== Тип ===

'''Статические поисковые структуры данных''' (англ. ''Online search structures'') предназначены для ответа на запросы на фиксированной базе данных.

'''Динамические поисковые структуры''' (англ. ''Offline search structures'') также позволяют вставки, удаления или модификации элементов между последовательными запросами. В динамическом случае, необходимо также учитывать стоимость изменения структуры данных. Любую динамическую структуру данных можно сделать статической, если запретить вставку и удаление. Также если множество ключей известно, то можно его заранее упорядочить так, чтобы избежать худших случаев в поисках в структурах данных.

=== Время работы ===

Эту классификацию обычно считают самой важной. Оценивают худшее время алгоритма, среднее и лучшее для каждой операции. Лучшее время {{---}} минимальное время работы алгоритма на каком-либо наборе. Худшее время {{---}} наибольшее время.

=== Используемая память ===

Параметр структуры данных, показывающий, сколько памяти ей требуется. Обычно затраты составляют <tex>O(n)</tex>.

=== Сравнение структур данных ===

Сравним эффективность поисковых структур данных для реализации интерфейса [[Упорядоченное множество|упорядоченного множества]]. Время работы методов <tex>Predecessor</tex> и <tex>Successor</tex> совпадает с временем работы <tex>Search</tex>.

<tex>n</tex> {{---}} количество хранимых чисел, каждое из которых представляется с помощью <tex>w</tex> битов.

{| class="wikitable"
|-
! rowspan="2" |
! colspan="2" | Insert
! colspan="2" | Delete
! colspan="2" | Search
! colspan="2" | Память
! rowspan="2" | Описание
|-
! style="background: #ddffdd;" | Среднее
! style="background: #ffdddd;" | Худшее
! style="background: #ddffdd;" | Среднее
! style="background: #ffdddd;" | Худшее
! style="background: #ddffdd;" | Среднее
! style="background: #ffdddd;" | Худшее
! style="background: #ddffdd;" | Среднее
! style="background: #ffdddd;" | Худшее
|-
!
! colspan="9" align="center" | Динамические структуры данных
|-
| Неотсортированный массив
| align="center" style="background: #ddffdd;" | <tex>O(1)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| align="center" style="background: #ddffdd;" | <tex>O(1)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | Наивная реализация, использующая [[Динамический массив|динамический массив]]. Добавление происходит в конец массива, а для поиска элемента просто проходим по всему массиву.
|-
| Отсортированный массив
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | То же самое, но теперь массив отсортирован. Поиск ускоряется за счёт возможности применить [[Целочисленный двоичный поиск|двоичный поиск]]. Вставка замедляется из-за необходимости поддерживать инвариант отсортированности.
|-
| Неотсортированный [[Список|список]]
| colspan="2" align="center" style="background: #ddffdd;" | <tex>O(1)</tex>
| colspan="2" align="center" style="background: #ddffdd;" | <tex>O(1)</tex>
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" rowspan="2" | Аналогично массиву, но храним данные в [[Список|списке]]. Можно хранить дополнительную информацию о вершинах, что позволит ускорить время работы операции delete.
|-
| Отсортированный [[Список|список]]
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| colspan="2" align="center" style="background: #ddffdd;" | <tex>O(1)</tex>
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
|-
| [[Дерево поиска, наивная реализация]]
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | Бинарное дерево поиска обладает следующим свойством: если <tex>x</tex> {{---}} узел бинарного дерева с ключом <tex>k</tex>, то все узлы в левом поддереве должны иметь ключи, меньшие <tex>k</tex>, а в правом поддереве большие <tex>k</tex>.
|-
| [[Рандомизированное бинарное дерево поиска]]
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | Вариант [[Дерево поиска, наивная реализация|двоисного дерево поиска]] с добавлением инвариата "случайности", что уменьнашает ожидаемую высоту дерева.
|-
|[[АВЛ-дерево]]
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | Сбалансированное [[Дерево поиска, наивная реализация|двоичное дерево поиска]], в котором поддерживается следующее свойство: для каждой его вершины высота её двух поддеревьев различается не более чем на <tex>1</tex>.
|-
|[[2-3 дерево]]
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | Структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
|-
|[[B-дерево]]
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | Cильноветвящееся сбалансированное дерево поиска, позволяющее проводить поиск, добавление и удаление элементов за <tex>O(\log n)</tex>. B-дерево с <tex>n</tex> узлами имеет высоту <tex>O(\log n)</tex>. Количество детей узлов может быть от нескольких до тысяч (обычно степень ветвления B-дерева определяется характеристиками устройства (дисков), на котором производится работа с деревом). В-деревья также могут использоваться для реализации многих операций над динамическими множествами за время <tex>O(\log n)</tex>
|-
|[[Красно-черное дерево]]
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | Сбалансированное [[Дерево поиска, наивная реализация|двоичное дерево поиска]], в котором баланс осуществляется на основе "цвета" узла дерева, который принимает только два значения: "красный" (англ. ''red'') и "чёрный" (англ. ''black''). При этом все листья дерева являются фиктивными и не содержат данных, но относятся к дереву и являются чёрными.
|-
| [[Декартово дерево]]
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | Бинарное дерево, в узлах которого хранится пары <tex> (x,y) </tex>, где <tex>x</tex> {{---}} это ключ, а <tex>y</tex> {{---}} это приоритет. Также оно является [[Дерево поиска, наивная реализация|двоичным деревом поиска]] по <tex>x</tex> и [[Двоичная куча|пирамидой]] по <tex>y</tex>. Предполагая, что все <tex>x</tex> и все <tex>y</tex> являются различными, получаем, что если некоторый элемент дерева содержит <tex>(x_0,y_0)</tex>, то у всех элементов в левом поддереве <tex>x < x_0</tex>, у всех элементов в правом поддереве <tex> x > x_0</tex>, а также и в левом, и в правом поддереве имеем: <tex> y < y_0</tex>.
|-
|[[Splay-дерево]]
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | [[Дерево поиска, наивная реализация|Двоичное дерево поиска]]. Оно позволяет находить быстрее те данные, которые использовались недавно, за счёт '''перемещения к корню''' (англ. ''Move to root''). Относится к разряду сливаемых деревьев. Сплей-дерево было придумано Робертом Тарьяном и Даниелем Слейтером в 1983 году.
|-
|[[Дерево ван Эмде Боаса]]
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log w)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log w)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log w)</tex>
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(2^w)</tex>
| align="center" | Cтруктура данных, представляющая собой [[Дерево поиска, наивная реализация|дерево поиска]], позволяющее хранить целые неотрицательные числа в интервале <tex>[0;2^w)</tex> и осуществлять над ними все соответствующие дереву поиска операции. Проще говоря, данная структура позволяет хранить <tex>w</tex>-битные числа.
Особенностью этой структуры является то, что все операции выполняются за <tex>O(\log w)</tex>, что асимптотически лучше, чем <tex>O(\log n)</tex> в большинстве других деревьев поиска, где <tex>n</tex> {{---}} количество элементов в дереве.
|-
| [[Список с пропусками]]
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | Вероятностная структура данных, основанная на нескольких отсортированных односвязных списках.
Отсортированный связный список является простейшей структурой с временем поиска <tex>\Theta(n)</tex>. Добавление дополнительных уровней, обеспечивающих быстрый доступ через несколько элементов, помогает улучшить асимптотику до <tex>\Theta(\log(n))</tex>
|-
|[[Fusion tree]]
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log_{w} n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log_{w} n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log_{w} n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | Дерево поиска, позволяющее хранить <tex>n</tex> <tex>w</tex>-битных чисел, используя <tex>O(n)</tex> памяти, и выполнять операции поиска за время <tex>O(\log_{w} n)</tex>. Эта структура данных была впервые предложена в 1990 году М. Фредманом (M. Fredman) и Д. Уиллардом (D. Willard).
|-
| [[Сверхбыстрый цифровой бор|Цифровой бор]]
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(w)</tex>
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(w)</tex>
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(w)</tex>
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(n \cdot w)</tex>
| align="center" | [[Бор]], в котором в качестве строк используются двоичные записи чисел, включая ведущие нули. Таким образом он имеет глубину <tex>w</tex>.
|-
| [[Сверхбыстрый цифровой бор|Быстрый цифровой бор]]
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(w)</tex>
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(w)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log w)</tex>
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(n \cdot w)</tex>
| align="center" | Улучшеная версия структуры цифрового бора.
|-
| [[Сверхбыстрый цифровой бор]]
| align="center" style="background: #ffffdd;" | <tex>O(\log w)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(w)</tex>
| align="center" style="background: #ffffdd;" | <tex>O(\log w)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(w)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log w)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | Улучшеная версия структуры быстрого цифрового бора.
|-
!
! colspan="9" align="center" | Статические структуры данных
|-
|[[Tango-дерево]]
| colspan="2" align="center" style="background: #e5e5e5;" | -
| colspan="2" align="center" style="background: #e5e5e5;" | -
| colspan="2" align="center" style="background: #ddffdd;" | <tex>O(\log \log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | [[Дерево поиска, наивная реализация|Двоичное дерево поиска]], которое изобрели Эрик Д. Демейн, Дион Хармон, Джон Яконо и Михаи Патраску в 2004 году. Не поддерживает операции вставки и удаления, но перестраивается по ходу поисковых запросов, чтобы отвечать на них как можно оптимальней. Это лучшая известная реализация на данный момент.
|}

==См. также==

*[[:Сортировка|Сортировка]]
*[[:Поиск_подстроки_в_строке|Поиск подстроки в строке]]
*[[:Приоритетные_кучи|Приоритетные кучи]]

== Источники информации ==

* [[wikipedia:en:Search_data_structure|Wikidedia {{---}} Search data structure]]
* [http://habrahabr.ru/post/188010/ Habrahabr {{---}} Знай сложности алгоритмов ]

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Деревья поиска]]
[[Категория: Структуры данных]]

Поисковые структуры данных

2015-05-25T12:26:08Z

194.85.160.130: /* Сравнение структур данных */

'''Поисковая структура данных''' {{---}} любая структура данных реализующая эффективный поиск конкретных элементов множества, например, конкретной записи в базе данных.

Простейший, наиболее общий, но менее эффективный поисковой структурой является простая неупорядоченный последовательная всех элементов. Расположив элементы в такой список, неизбежно возникнет ряд операций, которые потребуют линейного времени, в худшем случае, а также в средней случае. Используемые в реальной жизни поисковые структуры данных позволяют совершать операции более быстро, однако они ограничены запросами некоторого конкретного вида. Кроме того, поскольку стоимость построение таких структур пропорциональна <tex>n</tex>, их построение окупится, даже если поступает лишь несколько запросов.

=== Тип ===

'''Статические поисковые структуры данных''' (англ. ''Online search structures'') предназначены для ответа на запросы на фиксированной базе данных.

'''Динамические поисковые структуры''' (англ. ''Offline search structures'') также позволяют вставки, удаления или модификации элементов между последовательными запросами. В динамическом случае, необходимо также учитывать стоимость изменения структуры данных. Любую динамическую структуру данных можно сделать статической, если запретить вставку и удаление. Также если множество ключей известно, то можно его заранее упорядочить так, чтобы избежать худших случаев в поисках в структурах данных.

=== Время работы ===

Эту классификацию обычно считают самой важной. Оценивают худшее время алгоритма, среднее и лучшее для каждой операции. Лучшее время {{---}} минимальное время работы алгоритма на каком-либо наборе. Худшее время {{---}} наибольшее время.

=== Используемая память ===

Параметр структуры данных, показывающий, сколько памяти ей требуется. Обычно затраты составляют <tex>O(n)</tex>.

=== Сравнение структур данных ===

Сравним эффективность поисковых структур данных для реализации интерфейса [[Упорядоченное множество|упорядоченного множества]]. Время работы методов <tex>Predecessor</tex> и <tex>Successor</tex> совпадает с временем работы <tex>Search</tex>.

<tex>n</tex> {{---}} количество хранимых чисел, каждое из которых представляется с помощью <tex>w</tex> битов.

{| class="wikitable"
|-
! rowspan="2" |
! colspan="2" | Insert
! colspan="2" | Delete
! colspan="2" | Search
! colspan="2" | Память
! rowspan="2" | Описание
|-
! style="background: #ddffdd;" | Среднее
! style="background: #ffdddd;" | Худшее
! style="background: #ddffdd;" | Среднее
! style="background: #ffdddd;" | Худшее
! style="background: #ddffdd;" | Среднее
! style="background: #ffdddd;" | Худшее
! style="background: #ddffdd;" | Среднее
! style="background: #ffdddd;" | Худшее
|-
!
! colspan="9" align="center" | Динамические структуры данных
|-
| Неотсортированный массив
| align="center" style="background: #ddffdd;" | <tex>O(1)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| align="center" style="background: #ddffdd;" | <tex>O(1)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | Наивная реализация, использующая [[Динамический массив|динамический массив]]. Добавление происходит в конец массива, а для поиска элемента просто проходим по всему массиву.
|-
| Отсортированный массив
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | То же самое, но теперь массив отсортирован. Поиск ускоряется за счёт возможности применить [[Целочисленный двоичный поиск|двоичный поиск]]. Вставка замедляется из-за необходимости поддерживать инвариант отсортированности.
|-
| Неотсортированный [[Список|список]]
| colspan="2" align="center" style="background: #ddffdd;" | <tex>O(1)</tex>
| colspan="2" align="center" style="background: #ddffdd;" | <tex>O(1)</tex>
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" rowspan="2" | Аналогично массиву, но храним данные в [[Список|списке]]. Можно хранить дополнительную информацию о вершинах, что позволит ускорить время работы операции delete.
|-
| Отсортированный [[Список|список]]
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| colspan="2" align="center" style="background: #ddffdd;" | <tex>O(1)</tex>
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
|-
| [[Дерево поиска, наивная реализация]]
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | Бинарное дерево поиска обладает следующим свойством: если <tex>x</tex> {{---}} узел бинарного дерева с ключом <tex>k</tex>, то все узлы в левом поддереве должны иметь ключи, меньшие <tex>k</tex>, а в правом поддереве большие <tex>k</tex>.
|-
| [[Рандомизированное бинарное дерево поиска]]
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | Вариант [[Дерево поиска, наивная реализация|двоисного дерево поиска]] с добавлением инвариата "случайности", что уменьнашает ожидаемую высоту дерева.
|[[АВЛ-дерево]]
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | Сбалансированное [[Дерево поиска, наивная реализация|двоичное дерево поиска]], в котором поддерживается следующее свойство: для каждой его вершины высота её двух поддеревьев различается не более чем на <tex>1</tex>.
|-
|[[2-3 дерево]]
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | Структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
|-
|[[B-дерево]]
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | Cильноветвящееся сбалансированное дерево поиска, позволяющее проводить поиск, добавление и удаление элементов за <tex>O(\log n)</tex>. B-дерево с <tex>n</tex> узлами имеет высоту <tex>O(\log n)</tex>. Количество детей узлов может быть от нескольких до тысяч (обычно степень ветвления B-дерева определяется характеристиками устройства (дисков), на котором производится работа с деревом). В-деревья также могут использоваться для реализации многих операций над динамическими множествами за время <tex>O(\log n)</tex>
|-
|[[Красно-черное дерево]]
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | Сбалансированное [[Дерево поиска, наивная реализация|двоичное дерево поиска]], в котором баланс осуществляется на основе "цвета" узла дерева, который принимает только два значения: "красный" (англ. ''red'') и "чёрный" (англ. ''black''). При этом все листья дерева являются фиктивными и не содержат данных, но относятся к дереву и являются чёрными.
|-
| [[Декартово дерево]]
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | Бинарное дерево, в узлах которого хранится пары <tex> (x,y) </tex>, где <tex>x</tex> {{---}} это ключ, а <tex>y</tex> {{---}} это приоритет. Также оно является [[Дерево поиска, наивная реализация|двоичным деревом поиска]] по <tex>x</tex> и [[Двоичная куча|пирамидой]] по <tex>y</tex>. Предполагая, что все <tex>x</tex> и все <tex>y</tex> являются различными, получаем, что если некоторый элемент дерева содержит <tex>(x_0,y_0)</tex>, то у всех элементов в левом поддереве <tex>x < x_0</tex>, у всех элементов в правом поддереве <tex> x > x_0</tex>, а также и в левом, и в правом поддереве имеем: <tex> y < y_0</tex>.
|-
|[[Splay-дерево]]
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | [[Дерево поиска, наивная реализация|Двоичное дерево поиска]]. Оно позволяет находить быстрее те данные, которые использовались недавно, за счёт '''перемещения к корню''' (англ. ''Move to root''). Относится к разряду сливаемых деревьев. Сплей-дерево было придумано Робертом Тарьяном и Даниелем Слейтером в 1983 году.
|-
|[[Дерево ван Эмде Боаса]]
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log w)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log w)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log w)</tex>
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(2^w)</tex>
| align="center" | Cтруктура данных, представляющая собой [[Дерево поиска, наивная реализация|дерево поиска]], позволяющее хранить целые неотрицательные числа в интервале <tex>[0;2^w)</tex> и осуществлять над ними все соответствующие дереву поиска операции. Проще говоря, данная структура позволяет хранить <tex>w</tex>-битные числа.
Особенностью этой структуры является то, что все операции выполняются за <tex>O(\log w)</tex>, что асимптотически лучше, чем <tex>O(\log n)</tex> в большинстве других деревьев поиска, где <tex>n</tex> {{---}} количество элементов в дереве.
|-
| [[Список с пропусками]]
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | Вероятностная структура данных, основанная на нескольких отсортированных односвязных списках.
Отсортированный связный список является простейшей структурой с временем поиска <tex>\Theta(n)</tex>. Добавление дополнительных уровней, обеспечивающих быстрый доступ через несколько элементов, помогает улучшить асимптотику до <tex>\Theta(\log(n))</tex>
|-
|[[Fusion tree]]
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log_{w} n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log_{w} n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log_{w} n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | Дерево поиска, позволяющее хранить <tex>n</tex> <tex>w</tex>-битных чисел, используя <tex>O(n)</tex> памяти, и выполнять операции поиска за время <tex>O(\log_{w} n)</tex>. Эта структура данных была впервые предложена в 1990 году М. Фредманом (M. Fredman) и Д. Уиллардом (D. Willard).
|-
| [[Сверхбыстрый цифровой бор|Цифровой бор]]
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(w)</tex>
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(w)</tex>
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(w)</tex>
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(n \cdot w)</tex>
| align="center" | [[Бор]], в котором в качестве строк используются двоичные записи чисел, включая ведущие нули. Таким образом он имеет глубину <tex>w</tex>.
|-
| [[Сверхбыстрый цифровой бор|Быстрый цифровой бор]]
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(w)</tex>
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(w)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log w)</tex>
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(n \cdot w)</tex>
| align="center" | Улучшеная версия структуры цифрового бора.
|-
| [[Сверхбыстрый цифровой бор]]
| align="center" style="background: #ffffdd;" | <tex>O(\log w)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(w)</tex>
| align="center" style="background: #ffffdd;" | <tex>O(\log w)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(w)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log w)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | Улучшеная версия структуры быстрого цифрового бора.
|-
!
! colspan="9" align="center" | Статические структуры данных
|-
|[[Tango-дерево]]
| colspan="2" align="center" style="background: #e5e5e5;" | -
| colspan="2" align="center" style="background: #e5e5e5;" | -
| colspan="2" align="center" style="background: #ddffdd;" | <tex>O(\log \log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | [[Дерево поиска, наивная реализация|Двоичное дерево поиска]], которое изобрели Эрик Д. Демейн, Дион Хармон, Джон Яконо и Михаи Патраску в 2004 году. Не поддерживает операции вставки и удаления, но перестраивается по ходу поисковых запросов, чтобы отвечать на них как можно оптимальней. Это лучшая известная реализация на данный момент.
|}

==См. также==

*[[:Сортировка|Сортировка]]
*[[:Поиск_подстроки_в_строке|Поиск подстроки в строке]]
*[[:Приоритетные_кучи|Приоритетные кучи]]

== Источники информации ==

* [[wikipedia:en:Search_data_structure|Wikidedia {{---}} Search data structure]]
* [http://habrahabr.ru/post/188010/ Habrahabr {{---}} Знай сложности алгоритмов ]

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Деревья поиска]]
[[Категория: Структуры данных]]

Поисковые структуры данных

2015-05-25T12:24:28Z

194.85.160.130: /* Тип */

'''Поисковая структура данных''' {{---}} любая структура данных реализующая эффективный поиск конкретных элементов множества, например, конкретной записи в базе данных.

Простейший, наиболее общий, но менее эффективный поисковой структурой является простая неупорядоченный последовательная всех элементов. Расположив элементы в такой список, неизбежно возникнет ряд операций, которые потребуют линейного времени, в худшем случае, а также в средней случае. Используемые в реальной жизни поисковые структуры данных позволяют совершать операции более быстро, однако они ограничены запросами некоторого конкретного вида. Кроме того, поскольку стоимость построение таких структур пропорциональна <tex>n</tex>, их построение окупится, даже если поступает лишь несколько запросов.

=== Тип ===

'''Статические поисковые структуры данных''' (англ. ''Online search structures'') предназначены для ответа на запросы на фиксированной базе данных.

'''Динамические поисковые структуры''' (англ. ''Offline search structures'') также позволяют вставки, удаления или модификации элементов между последовательными запросами. В динамическом случае, необходимо также учитывать стоимость изменения структуры данных. Любую динамическую структуру данных можно сделать статической, если запретить вставку и удаление. Также если множество ключей известно, то можно его заранее упорядочить так, чтобы избежать худших случаев в поисках в структурах данных.

=== Время работы ===

Эту классификацию обычно считают самой важной. Оценивают худшее время алгоритма, среднее и лучшее для каждой операции. Лучшее время {{---}} минимальное время работы алгоритма на каком-либо наборе. Худшее время {{---}} наибольшее время.

=== Используемая память ===

Параметр структуры данных, показывающий, сколько памяти ей требуется. Обычно затраты составляют <tex>O(n)</tex>.

=== Сравнение структур данных ===

Сравним эффективность поисковых структур данных для реализации интерфейса [[Упорядоченное множество|упорядоченного множества]]. Время работы методов <tex>Predecessor</tex> и <tex>Successor</tex> совпадает с временем работы <tex>Search</tex>.

<tex>n</tex> {{---}} количество хранимых чисел, каждое из которых представляется с помощью <tex>w</tex> битов.

{| class="wikitable"
|-
! rowspan="2" |
! colspan="2" | Insert
! colspan="2" | Delete
! colspan="2" | Search
! colspan="2" | Память
! rowspan="2" | Описание
|-
! style="background: #ddffdd;" | Среднее
! style="background: #ffdddd;" | Худшее
! style="background: #ddffdd;" | Среднее
! style="background: #ffdddd;" | Худшее
! style="background: #ddffdd;" | Среднее
! style="background: #ffdddd;" | Худшее
! style="background: #ddffdd;" | Среднее
! style="background: #ffdddd;" | Худшее
|-
!
! colspan="9" align="center" | Динамические структуры данных
|-
| Неотсортированный массив
| align="center" style="background: #ddffdd;" | <tex>O(1)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| align="center" style="background: #ddffdd;" | <tex>O(1)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | Наивная реализация, использующая [[Динамический массив|динамический массив]]. Добавление происходит в конец массива, а для поиска элемента просто проходим по всему массиву.
|-
| Отсортированный массив
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | То же самое, но теперь массив отсортирован. Поиск ускоряется за счёт возможности применить [[Целочисленный двоичный поиск|двоичный поиск]]. Вставка замедляется из-за необходимости поддерживать инвариант отсортированности.
|-
| Неотсортированный [[Список|список]]
| colspan="2" align="center" style="background: #ddffdd;" | <tex>O(1)</tex>
| colspan="2" align="center" style="background: #ddffdd;" | <tex>O(1)</tex>
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" rowspan="2" | Аналогично массиву, но храним данные в [[Список|списке]]. Можно хранить дополнительную информацию о вершинах, что позволит ускорить время работы операции delete.
|-
| Отсортированный [[Список|список]]
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| colspan="2" align="center" style="background: #ddffdd;" | <tex>O(1)</tex>
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
|-
| [[Дерево поиска, наивная реализация]]
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | Бинарное дерево поиска обладает следующим свойством: если <tex>x</tex> {{---}} узел бинарного дерева с ключом <tex>k</tex>, то все узлы в левом поддереве должны иметь ключи, меньшие <tex>k</tex>, а в правом поддереве большие <tex>k</tex>.
|-
| [[Рандомизированное бинарное дерево поиска]]
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | Вариант [[Дерево поиска, наивная реализация|двоисного дерево поиска]] с добавлением инвариата "случайности". Что дает возможность того, что математическое ожидание глубины дерева будет небольшим.
|-
|[[АВЛ-дерево]]
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | Сбалансированное [[Дерево поиска, наивная реализация|двоичное дерево поиска]], в котором поддерживается следующее свойство: для каждой его вершины высота её двух поддеревьев различается не более чем на <tex>1</tex>.
|-
|[[2-3 дерево]]
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | Структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
|-
|[[B-дерево]]
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | Cильноветвящееся сбалансированное дерево поиска, позволяющее проводить поиск, добавление и удаление элементов за <tex>O(\log n)</tex>. B-дерево с <tex>n</tex> узлами имеет высоту <tex>O(\log n)</tex>. Количество детей узлов может быть от нескольких до тысяч (обычно степень ветвления B-дерева определяется характеристиками устройства (дисков), на котором производится работа с деревом). В-деревья также могут использоваться для реализации многих операций над динамическими множествами за время <tex>O(\log n)</tex>
|-
|[[Красно-черное дерево]]
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | Сбалансированное [[Дерево поиска, наивная реализация|двоичное дерево поиска]], в котором баланс осуществляется на основе "цвета" узла дерева, который принимает только два значения: "красный" (англ. ''red'') и "чёрный" (англ. ''black''). При этом все листья дерева являются фиктивными и не содержат данных, но относятся к дереву и являются чёрными.
|-
| [[Декартово дерево]]
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | Бинарное дерево, в узлах которого хранится пары <tex> (x,y) </tex>, где <tex>x</tex> {{---}} это ключ, а <tex>y</tex> {{---}} это приоритет. Также оно является [[Дерево поиска, наивная реализация|двоичным деревом поиска]] по <tex>x</tex> и [[Двоичная куча|пирамидой]] по <tex>y</tex>. Предполагая, что все <tex>x</tex> и все <tex>y</tex> являются различными, получаем, что если некоторый элемент дерева содержит <tex>(x_0,y_0)</tex>, то у всех элементов в левом поддереве <tex>x < x_0</tex>, у всех элементов в правом поддереве <tex> x > x_0</tex>, а также и в левом, и в правом поддереве имеем: <tex> y < y_0</tex>.
|-
|[[Splay-дерево]]
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | [[Дерево поиска, наивная реализация|Двоичное дерево поиска]]. Оно позволяет находить быстрее те данные, которые использовались недавно, за счёт '''перемещения к корню''' (англ. ''Move to root''). Относится к разряду сливаемых деревьев. Сплей-дерево было придумано Робертом Тарьяном и Даниелем Слейтером в 1983 году.
|-
|[[Дерево ван Эмде Боаса]]
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log w)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log w)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log w)</tex>
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(2^w)</tex>
| align="center" | Cтруктура данных, представляющая собой [[Дерево поиска, наивная реализация|дерево поиска]], позволяющее хранить целые неотрицательные числа в интервале <tex>[0;2^w)</tex> и осуществлять над ними все соответствующие дереву поиска операции. Проще говоря, данная структура позволяет хранить <tex>w</tex>-битные числа.
Особенностью этой структуры является то, что все операции выполняются за <tex>O(\log w)</tex>, что асимптотически лучше, чем <tex>O(\log n)</tex> в большинстве других деревьев поиска, где <tex>n</tex> {{---}} количество элементов в дереве.
|-
| [[Список с пропусками]]
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| align="center" style="background: #ffffdd;" | <tex>O(\log n)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | Вероятностная структура данных, основанная на нескольких отсортированных односвязных списках.
Отсортированный связный список является простейшей структурой с временем поиска <tex>\Theta(n)</tex>. Добавление дополнительных уровней, обеспечивающих быстрый доступ через несколько элементов, помогает улучшить асимптотику до <tex>\Theta(\log(n))</tex>
|-
|[[Fusion tree]]
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log_{w} n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log_{w} n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log_{w} n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | Дерево поиска, позволяющее хранить <tex>n</tex> <tex>w</tex>-битных чисел, используя <tex>O(n)</tex> памяти, и выполнять операции поиска за время <tex>O(\log_{w} n)</tex>. Эта структура данных была впервые предложена в 1990 году М. Фредманом (M. Fredman) и Д. Уиллардом (D. Willard).
|-
| [[Сверхбыстрый цифровой бор|Цифровой бор]]
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(w)</tex>
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(w)</tex>
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(w)</tex>
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(n \cdot w)</tex>
| align="center" | [[Бор]], в котором в качестве строк используются двоичные записи чисел, включая ведущие нули. Таким образом он имеет глубину <tex>w</tex>.
|-
| [[Сверхбыстрый цифровой бор|Быстрый цифровой бор]]
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(w)</tex>
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(w)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log w)</tex>
| colspan="2" align="center" style="background: #ffdddd;" | <tex>O(n \cdot w)</tex>
| align="center" | Улучшеная версия структуры цифрового бора.
|-
| [[Сверхбыстрый цифровой бор]]
| align="center" style="background: #ffffdd;" | <tex>O(\log w)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(w)</tex>
| align="center" style="background: #ffffdd;" | <tex>O(\log w)</tex>
| align="center" style="background: #ffdddd;" | <tex>O(w)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(\log w)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | Улучшеная версия структуры быстрого цифрового бора.
|-
!
! colspan="9" align="center" | Статические структуры данных
|-
|[[Tango-дерево]]
| colspan="2" align="center" style="background: #e5e5e5;" | -
| colspan="2" align="center" style="background: #e5e5e5;" | -
| colspan="2" align="center" style="background: #ddffdd;" | <tex>O(\log \log n)</tex>
| colspan="2" align="center" style="background: #ffffdd;" | <tex>O(n)</tex>
| align="center" | [[Дерево поиска, наивная реализация|Двоичное дерево поиска]], которое изобрели Эрик Д. Демейн, Дион Хармон, Джон Яконо и Михаи Патраску в 2004 году. Не поддерживает операции вставки и удаления, но перестраивается по ходу поисковых запросов, чтобы отвечать на них как можно оптимальней. Это лучшая известная реализация на данный момент.
|}

==См. также==

*[[:Сортировка|Сортировка]]
*[[:Поиск_подстроки_в_строке|Поиск подстроки в строке]]
*[[:Приоритетные_кучи|Приоритетные кучи]]

== Источники информации ==

* [[wikipedia:en:Search_data_structure|Wikidedia {{---}} Search data structure]]
* [http://habrahabr.ru/post/188010/ Habrahabr {{---}} Знай сложности алгоритмов ]

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Деревья поиска]]
[[Категория: Структуры данных]]

Предиктивный синтаксический анализ

2015-05-25T12:23:34Z

194.85.160.130: /* Общая схема построения рекурсивных парсеров с помощью FIRST и FOLLOW */

Для [[LL(k)-грамматики, множества FIRST и FOLLOW | LL(1)-грамматик]] возможна автоматическая генерация парсеров, если известны множества FIRST и FOLLOW. Существуют общедоступные генераторы: ANTLR<ref>[http://www.antlr.org/ ANTLR {{---}} Parser generator]</ref>, Bison<ref>[http://www.gnu.org/software/bison/ Bison {{---}} GNU Project]</ref>, Yacc<ref>[http://dinosaur.compilertools.net/ Lex & Yacc {{---}} A Lexical Analyzer Generator and Yet Another Compiler-Compiler]</ref>, Happy<ref>[https://www.haskell.org/happy/ Happy {{---}} The Parser Generator for Haskell]</ref>.

== Общая схема построения рекурсивных парсеров с помощью FIRST и FOLLOW ==

Пусть <tex>\Gamma =\langle \Sigma, N, S, P \rangle</tex> {{---}} LL(1)-грамматика. Построим для нее парсер.

Для каждого нетерминала <tex>A : A \rightarrow \alpha_1 \mid \alpha_2 \mid \ldots \mid \alpha_k </tex> создадим функцию <tex> \mathtt{A}() : \mathtt{Node} </tex>, возвращающую фрагмент [[Контекстно-свободные грамматики, вывод, лево- и правосторонний вывод, дерево разбора#Дерево разбора | дерева разбора]], выведенный из нетерминала <tex>A</tex>.

Здесь <tex>\mathtt{Node}</tex> {{---}} структура следующего вида:
'''struct''' Node
children : '''list<Node>'''
value : '''string''' // имя нетерминала или текст терминала
'''function''' addChild('''Node''') // функция, подвешивающая поддерево к данному узлу

Каждый момент времени парсер работает с определённым '''токеном''' (англ. ''token'') входного слово <tex>s</tex>. Токен {{---}} один или несколько нетерминалов, для удобства объединяемые по смыслу в одну логическую единицы. Примерами токенов могут выступать следующие лексические единицы:
* произвольный символ <tex> c </tex>,
* целое слово, например <tex> public </tex>,
* число со знаком, обозначаемое далее для краткости как <tex> n </tex>.
В общем случае, токеном может являться любое слово, удовлетворяющее произвольному [[Регулярные языки: два определения и их эквивалентность | регулярному выражению]].

[[Файл:string_token.png|300px]]

Здесь <tex>\$</tex> обозначает маркер конца строки.

В псевдокоде используются следующие обозначения:
* <tex>\mathtt{curToken}</tex> {{---}} текущий токен строки,
* <tex>\mathtt{nextToken()}</tex> {{---}} функция, записывающая в <tex>\mathtt{curToken}</tex> следующий за ним токен.

Тогда шаблон функции рекурсивного парсера для нетерминала <tex>A</tex> имеет вид:

A() : '''Node'''
Node res = Node("A")
'''switch''' (curToken) : // принимаем решение в зависимости от текущего токена строки
'''case''' <tex>\mathrm{FIRST}(\alpha_1) \cup (\mathrm{FOLLOW}(A)\ \mathrm{if}\ \varepsilon \in \mathrm{FIRST}(\alpha_1))</tex> :
// <tex>\alpha_1 = X_1X_2 \ldots X_{t}</tex> 
'''for''' i = 1 .. t
'''if''' <tex> X_i </tex> {{---}} нетерминал
consume(<tex>X_i</tex>)
res.addChild(Node("<tex>X_i</tex>")
nextToken()
'''else''' // <tex>X_i</tex> {{---}} терминал, нужно вызвать соответствующую ему функцию рекурсивного парсера 
Node t = <tex>X_i()</tex>
res.addChild(t)
'''break'''
'''case''' <tex>\mathrm{FIRST}(\alpha_2) \cup (\mathrm{FOLLOW}(A)\ \mathrm{if}\ \varepsilon \in \mathrm{FIRST}(\alpha_2))</tex> :
<tex>\ldots</tex>
'''break'''
<tex>\ldots</tex>
'''default''' :
error("unexpected char")
'''return''' res

'''function''' consume(c: '''char''')
'''if''' curToken != c
error("expected " + c)
nextToken()

Такой парсер не только разбирает строку, но и находит ошибки в неудовлетворяющих грамматике выражениях.

== Пример ==
Рассмотрим построение парсера на примере LL(1)-грамматики арифметических выражений, которая уже была разобрана [[Построение FIRST и FOLLOW#Пример | ранее]]:

<tex>
E \to TE' \\
E' \to +TE' \mid \varepsilon \\
T \to FT' \\
T' \to * FT' \mid \varepsilon \\
F \to n \mid (E)
</tex>

Напомним, что множества <tex>\mathrm{FIRST}</tex> и <tex>\mathrm{FOLLOW}</tex> для неё выглядят так:

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Правило
!style="background-color:#EEE"| FIRST
!style="background-color:#EEE"| FOLLOW
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \varepsilon\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ ,\ )\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ *,\ \varepsilon\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ ,\ )\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ *, \ +,\ \$\ ,\ )\ \} </tex>
|}

=== Псевдокоды ===
Построим функции обработки некоторых нетерминалов, используя описанный выше шаблон:

E() : '''Node'''
Node res = Node("E")
'''switch''' (curToken)
'''case''' n, '(' :
res.addChild(T())
res.addChild(E'())
'''break'''
'''default''' :
error("unexpected char")
'''return''' res

E'() : '''Node'''
Node res = Node("E'")
'''switch''' (curToken)
'''case''' '+' :
consume('+')
res.addChild(Node("+"))
res.addChild(T())
res.addChild(E'())
'''break'''
'''case''' '$', ')' :
'''break'''
'''default''' :
error("unexpected char")
'''return''' res

F() : '''Node'''
Node res = Node("F")
'''switch''' (curToken)
'''case''' n :
consume(n)
res.addChild(Node(curToken)) // <tex>\mathtt{curToken}</tex> подпадает под шаблон <tex>n</tex>, поэтому запишем его в <tex>\mathtt{value}</tex> вершины
'''break'''
'''case''' '(' :
consume('(')
res.addChild(Node("("))
res.addChild(E())
consume(')')
res.addChild(Node(")"))
'''default''' :
error("unexpected char")
'''return''' res

Функции для <tex>T</tex> и <tex>T'</tex> строятся аналогично.

=== Дерево разбора ===

Рассмотрим дерево разбора для выражения <tex>(1 + 2) * 3</tex> и несколько первых шагов алгоритма рекурсивного разбора. Сначала вызывается функция стартового нетерминала грамматики, то есть <tex>E</tex>. Так как первым токеном является '(', то будет использовано первое правило разбора <tex>TE'</tex>. Поэтому к вершине с меткой <tex>E</tex> добавятся два ребёнка: <tex>T</tex> и <tex>E'</tex>. А рекурсивный разборщик перейдёт к нетерминалу <tex>T</tex>. По-прежнему curToken равен '(', поэтому в <tex>F</tex> сработает второй case, первым ребёнком добавится '(', curToken станет равен <tex>1</tex>, а разборщик перейдёт к нетерминалу <tex>E</tex>. После того как выражение после '(', которое выводится из <tex>E</tex>, будет полностью разобрано, функция рекурсивного разбора для <tex>F</tex> добавит ')' последним сыном к этому нетерминалу.

Продолжая в том же духе, мы построим всё дерево разбора данного выражения.

[[Файл:parse_ex1.png|400px|thumb|center|Дерево разбора выражения <tex>(1 + 2) * 3</tex>]]

== Нерекурсивный нисходящий парсер ==

[[Файл:Parse_table.png|400px|right]]

Рекурсивные разборщики можно генерировать автоматически, зная множества <tex>\mathrm{FIRST}</tex> и <tex>\mathrm{FOLLOW}</tex>, так как они имеют достаточно прозрачный шаблон построения. Альтернативным способом осуществления нисходящего синтаксического анализа является построение нерекурсивного нисходящего парсера. Его можно построить с помощью явного использования [[Стек | стека]] (вместо неявного при рекурсивных вызовах). Такой анализатор имитирует
[[Контекстно-свободные грамматики, вывод, лево- и правосторонний вывод, дерево разбора#Лево- и правосторонний вывод слова | левое порождение]].

Стек нерекурсивного предиктивного синтаксического анализатора содержит последовательность терминалов и нетерминалов и таблицу синтаксического анализа. На стеке располагается последовательность символов грамматики с маркером конца разбора <tex>\perp</tex> на дне. В начале процесса анализа строки стек содержит стартовый нетерминал грамматики непосредственно над символом <tex>\perp</tex>. Таблица синтаксического анализа представляет собой двухмерный массив <tex>\mathcal{M}[A, c]</tex>, где <tex>A</tex> {{---}} нетерминал или <tex>\perp</tex>, <tex> c </tex> {{---}} токен или символ конца строки <tex>\$</tex>.

Нерекурсивный синтаксический анализатор смотрит на текущий токен <tex> c </tex> входного слова и на символ на вершине стека <tex>A</tex>, а затем принимает решение в зависимости от одного из возникающих ниже случаев:
* если <tex>A\ =\ \perp\ \land\ c\ =\ \$</tex>, то синтаксический анализатор прекращает работу, так как разбор строки завершён,
* eсли <tex>A = c</tex>, то синтаксический анализатор снимает со стека токен <tex>A</tex> и перемещает указатель текущего токена ленты к следующему токену (то есть вызывает <tex>\mathtt{nextToken}</tex>), таким образом, происходит выброс символа <tex> c </tex> со стека,
* eсли <tex>A</tex> представляет собой нетерминал, то программа рассматривает запись <tex>\mathcal{M}[A,c]</tex> таблицы разбора <tex>\mathcal{M}</tex>. Эта запись представляет собой либо продукцию грамматики вида <tex>A \to \alpha_i,\ \alpha_i = X_1 X_2 \ldots X_t</tex>, и тогда <tex>\mathcal{M}[A,c]</tex> содержит номер <tex>i</tex> данной продукции, либо запись об ошибке, и тогда <tex>\mathcal{M}[A,c] = \varnothing</tex>. Если <tex>\mathcal{M}[A,c] \neq \varnothing</tex>, то синтаксический анализатор замещает на стеке нетерминал <tex> A </tex> правой частью правила с номером <tex> i </tex>, помещая символы правила на стек в обратном порядке,
* во всех остальных случаях парсер бросает сообщение об ошибке.

Рассмотренные случаи отображены коротко на картинке справа, где блок <tex> N </tex> отвечает нетерминалам грамматики. Из картинки видно, что вместо рассмотрения всех случаев в коде, достаточно просто создать таблицу <tex>\mathcal{M}</tex> таким образом, чтобы она учитывала все случаи, что упростит код.

=== Псевдокод ===

Здесь по-прежнему <tex>\mathtt{curToken}</tex> обозначает текущий токен строки, а <tex>\mathtt{nextToken}</tex> передвигает указатель на следующий токен.

<code style = "display: inline-block;">
'''function''' nonRecursiveParser():
st : '''Stack'''
st.push(<tex>\perp</tex>)
st.push(<tex>S</tex>) // здесь <tex> S </tex> {{---}} стартовый нетерминал грамматики
'''while''' s.top() <tex>\neq\ \perp</tex>
A = st.top()
'''if''' <tex>\mathcal{M}[A,\ curToken]\ ==\ \mathrm{ok}</tex> // <tex> A\ ==\ \perp </tex> и <tex>\mathtt{curToken}\ ==\ \$</tex>
'''break''' // разбор строки завершён
'''else if''' <tex>\mathcal{M}[A,\ curToken]\ ==\ \nearrow</tex> // выброс
nextToken()
st.pop()
вывести в выходной поток нетерминал, отвечающий <tex>\mathtt{curToken}</tex>
'''else if''' <tex>\mathcal{M}[A,\ curToken]</tex> {{---}} номер правила <tex>A \to \alpha_i,\ \alpha_i = X_1 X_2 \ldots X_t</tex>
st.pop()
'''for''' k = t '''downto''' 1
st.push(<tex>X_k</tex>)
вывести в выходной поток терминал, отвечающий <tex>A</tex>
'''else'''
error("unexpected symbol")
</code>

=== Пример ===

Рассмотрим пример работы нерекурсивного парсера на всё той же грамматике арифметических выражений. Для начала пронумеруем все правила:

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Номер
!style="background-color:#EEE"| Правило
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>1</tex>
|style="background-color:#FFF;padding:2px 10px"| <tex>E \to TE'</tex>
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>2</tex>
|style="background-color:#FFF;padding:2px 10px"| <tex>E' \to +TE'</tex>
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>3</tex>
|style="background-color:#FFF;padding:2px 10px"| <tex>E' \to \varepsilon</tex>
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>4</tex>
|style="background-color:#FFF;padding:2px 10px"| <tex>T \to FT'</tex>
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>5</tex>
|style="background-color:#FFF;padding:2px 10px"| <tex>T' \to * FT'</tex>
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>6</tex>
|style="background-color:#FFF;padding:2px 10px"| <tex>T' \to \varepsilon</tex>
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>7</tex>
|style="background-color:#FFF;padding:2px 10px"| <tex>F \to n</tex>
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>8</tex>
|style="background-color:#FFF;padding:2px 10px"| <tex>F \to (E)</tex>
|}

Теперь можно построить часть таблицы <tex>\mathcal{M}</tex>, содержащей строки, отвечающие нетерминалам. Её построение легко осуществить, если известны <tex>\mathrm{FIRST}</tex> и <tex>\mathrm{FOLLOW}</tex>. По сути по этим множествам можно понять, какое правило использовать для данного нетерминала при текущем токене.

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"|
!style="background-color:#EEE;text-align:center;"| <tex>n</tex>
!style="background-color:#EEE;text-align:center;"| <tex>(</tex>
!style="background-color:#EEE;text-align:center;"| <tex>)</tex>
!style="background-color:#EEE;text-align:center;"| <tex>+</tex>
!style="background-color:#EEE;text-align:center;"| <tex>*</tex>
!style="background-color:#EEE;text-align:center;"| <tex>\$</tex>
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>E</tex>
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>1 </tex>
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>1 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>3 </tex>
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>2 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>3 </tex>
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>T</tex>
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>4 </tex>
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>4 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>6 </tex>
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>6 </tex>
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>5 </tex>
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>6 </tex>
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>F</tex>
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>7 </tex>
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>8 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>\perp</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>\mathrm{ok}</tex>
|}

На картинке ниже показаны состояние стека на нескольких первых итерациях цикла и указатель на текущий токен.

[[Файл:Parse_stack.png|500px]]

== Примечания ==
<references/>
== Источники информации ==
* Альфред Ахо, Рави Сети, Джеффри Ульман. Компиляторы. Принципы, технологии, инструменты. Издательство Вильямс. Второе издание. 2008. Стр. 288 {{---}} 294.

[[Категория: Методы трансляции]]
[[Категория: Нисходящий разбор]]

Предиктивный синтаксический анализ

2015-05-25T12:22:04Z

194.85.160.130: готов

Для [[LL(k)-грамматики, множества FIRST и FOLLOW | LL(1)-грамматик]] возможна автоматическая генерация парсеров, если известны множества FIRST и FOLLOW. Существуют общедоступные генераторы: ANTLR<ref>[http://www.antlr.org/ ANTLR {{---}} Parser generator]</ref>, Bison<ref>[http://www.gnu.org/software/bison/ Bison {{---}} GNU Project]</ref>, Yacc<ref>[http://dinosaur.compilertools.net/ Lex & Yacc {{---}} A Lexical Analyzer Generator and Yet Another Compiler-Compiler]</ref>, Happy<ref>[https://www.haskell.org/happy/ Happy {{---}} The Parser Generator for Haskell]</ref>.

== Общая схема построения рекурсивных парсеров с помощью FIRST и FOLLOW ==

Пусть <tex>\Gamma =\langle \Sigma, N, S, P \rangle</tex> {{---}} LL(1)-грамматика. Построим для нее парсер.

Для каждого нетерминала <tex>A : A \rightarrow \alpha_1 \mid \alpha_2 \mid \ldots \mid \alpha_k </tex> создадим функцию <tex> \mathtt{A}() : \mathtt{Node} </tex>, возвращающую фрагмент дерева разбора, выведенный из нетерминала <tex>A</tex>.

Здесь <tex>\mathtt{Node}</tex> {{---}} структура следующего вида:
'''struct''' Node
children : '''list<Node>'''
value : '''string''' // имя нетерминала или текст терминала
'''function''' addChild('''Node''') // функция, подвешивающая поддерево к данному узлу

Каждый момент времени парсер работает с определённым '''токеном''' (англ. ''token'') входного слово <tex>s</tex>. Токен {{---}} один или несколько нетерминалов, для удобства объединяемые по смыслу в одну логическую единицы. Примерами токенов могут выступать следующие лексические единицы:
* произвольный символ <tex> c </tex>,
* целое слово, например <tex> public </tex>,
* число со знаком, обозначаемое далее для краткости как <tex> n </tex>.
В общем случае, токеном может являться любое слово, удовлетворяющее произвольному [[Регулярные языки: два определения и их эквивалентность | регулярному выражению]].

[[Файл:string_token.png|300px]]

Здесь <tex>\$</tex> обозначает маркер конца строки.

В псевдокоде используются следующие обозначения:
* <tex>\mathtt{curToken}</tex> {{---}} текущий токен строки,
* <tex>\mathtt{nextToken()}</tex> {{---}} функция, записывающая в <tex>\mathtt{curToken}</tex> следующий за ним токен.

Тогда шаблон функции рекурсивного парсера для нетерминала <tex>A</tex> имеет вид:

A() : '''Node'''
Node res = Node("A")
'''switch''' (curToken) : // принимаем решение в зависимости от текущего токена строки
'''case''' <tex>\mathrm{FIRST}(\alpha_1) \cup (\mathrm{FOLLOW}(A)\ \mathrm{if}\ \varepsilon \in \mathrm{FIRST}(\alpha_1))</tex> :
// <tex>\alpha_1 = X_1X_2 \ldots X_{t}</tex> 
'''for''' i = 1 .. t
'''if''' <tex> X_i </tex> {{---}} нетерминал
consume(<tex>X_i</tex>)
res.addChild(Node("<tex>X_i</tex>")
nextToken()
'''else''' // <tex>X_i</tex> {{---}} терминал, нужно вызвать соответствующую ему функцию рекурсивного парсера 
Node t = <tex>X_i()</tex>
res.addChild(t)
'''break'''
'''case''' <tex>\mathrm{FIRST}(\alpha_2) \cup (\mathrm{FOLLOW}(A)\ \mathrm{if}\ \varepsilon \in \mathrm{FIRST}(\alpha_2))</tex> :
<tex>\ldots</tex>
'''break'''
<tex>\ldots</tex>
'''default''' :
error("unexpected char")
'''return''' res

'''function''' consume(c: '''char''')
'''if''' curToken != c
error("expected " + c)
nextToken()

Такой парсер не только разбирает строку, но и находит ошибки в неудовлетворяющих грамматике выражениях.

== Пример ==
Рассмотрим построение парсера на примере LL(1)-грамматики арифметических выражений, которая уже была разобрана [[Построение FIRST и FOLLOW#Пример | ранее]]:

<tex>
E \to TE' \\
E' \to +TE' \mid \varepsilon \\
T \to FT' \\
T' \to * FT' \mid \varepsilon \\
F \to n \mid (E)
</tex>

Напомним, что множества <tex>\mathrm{FIRST}</tex> и <tex>\mathrm{FOLLOW}</tex> для неё выглядят так:

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Правило
!style="background-color:#EEE"| FIRST
!style="background-color:#EEE"| FOLLOW
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \varepsilon\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ ,\ )\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ *,\ \varepsilon\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ ,\ )\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ *, \ +,\ \$\ ,\ )\ \} </tex>
|}

=== Псевдокоды ===
Построим функции обработки некоторых нетерминалов, используя описанный выше шаблон:

E() : '''Node'''
Node res = Node("E")
'''switch''' (curToken)
'''case''' n, '(' :
res.addChild(T())
res.addChild(E'())
'''break'''
'''default''' :
error("unexpected char")
'''return''' res

E'() : '''Node'''
Node res = Node("E'")
'''switch''' (curToken)
'''case''' '+' :
consume('+')
res.addChild(Node("+"))
res.addChild(T())
res.addChild(E'())
'''break'''
'''case''' '$', ')' :
'''break'''
'''default''' :
error("unexpected char")
'''return''' res

F() : '''Node'''
Node res = Node("F")
'''switch''' (curToken)
'''case''' n :
consume(n)
res.addChild(Node(curToken)) // <tex>\mathtt{curToken}</tex> подпадает под шаблон <tex>n</tex>, поэтому запишем его в <tex>\mathtt{value}</tex> вершины
'''break'''
'''case''' '(' :
consume('(')
res.addChild(Node("("))
res.addChild(E())
consume(')')
res.addChild(Node(")"))
'''default''' :
error("unexpected char")
'''return''' res

Функции для <tex>T</tex> и <tex>T'</tex> строятся аналогично.

=== Дерево разбора ===

Рассмотрим дерево разбора для выражения <tex>(1 + 2) * 3</tex> и несколько первых шагов алгоритма рекурсивного разбора. Сначала вызывается функция стартового нетерминала грамматики, то есть <tex>E</tex>. Так как первым токеном является '(', то будет использовано первое правило разбора <tex>TE'</tex>. Поэтому к вершине с меткой <tex>E</tex> добавятся два ребёнка: <tex>T</tex> и <tex>E'</tex>. А рекурсивный разборщик перейдёт к нетерминалу <tex>T</tex>. По-прежнему curToken равен '(', поэтому в <tex>F</tex> сработает второй case, первым ребёнком добавится '(', curToken станет равен <tex>1</tex>, а разборщик перейдёт к нетерминалу <tex>E</tex>. После того как выражение после '(', которое выводится из <tex>E</tex>, будет полностью разобрано, функция рекурсивного разбора для <tex>F</tex> добавит ')' последним сыном к этому нетерминалу.

Продолжая в том же духе, мы построим всё дерево разбора данного выражения.

[[Файл:parse_ex1.png|400px|thumb|center|Дерево разбора выражения <tex>(1 + 2) * 3</tex>]]

== Нерекурсивный нисходящий парсер ==

[[Файл:Parse_table.png|400px|right]]

Рекурсивные разборщики можно генерировать автоматически, зная множества <tex>\mathrm{FIRST}</tex> и <tex>\mathrm{FOLLOW}</tex>, так как они имеют достаточно прозрачный шаблон построения. Альтернативным способом осуществления нисходящего синтаксического анализа является построение нерекурсивного нисходящего парсера. Его можно построить с помощью явного использования [[Стек | стека]] (вместо неявного при рекурсивных вызовах). Такой анализатор имитирует
[[Контекстно-свободные грамматики, вывод, лево- и правосторонний вывод, дерево разбора#Лево- и правосторонний вывод слова | левое порождение]].

Стек нерекурсивного предиктивного синтаксического анализатора содержит последовательность терминалов и нетерминалов и таблицу синтаксического анализа. На стеке располагается последовательность символов грамматики с маркером конца разбора <tex>\perp</tex> на дне. В начале процесса анализа строки стек содержит стартовый нетерминал грамматики непосредственно над символом <tex>\perp</tex>. Таблица синтаксического анализа представляет собой двухмерный массив <tex>\mathcal{M}[A, c]</tex>, где <tex>A</tex> {{---}} нетерминал или <tex>\perp</tex>, <tex> c </tex> {{---}} токен или символ конца строки <tex>\$</tex>.

Нерекурсивный синтаксический анализатор смотрит на текущий токен <tex> c </tex> входного слова и на символ на вершине стека <tex>A</tex>, а затем принимает решение в зависимости от одного из возникающих ниже случаев:
* если <tex>A\ =\ \perp\ \land\ c\ =\ \$</tex>, то синтаксический анализатор прекращает работу, так как разбор строки завершён,
* eсли <tex>A = c</tex>, то синтаксический анализатор снимает со стека токен <tex>A</tex> и перемещает указатель текущего токена ленты к следующему токену (то есть вызывает <tex>\mathtt{nextToken}</tex>), таким образом, происходит выброс символа <tex> c </tex> со стека,
* eсли <tex>A</tex> представляет собой нетерминал, то программа рассматривает запись <tex>\mathcal{M}[A,c]</tex> таблицы разбора <tex>\mathcal{M}</tex>. Эта запись представляет собой либо продукцию грамматики вида <tex>A \to \alpha_i,\ \alpha_i = X_1 X_2 \ldots X_t</tex>, и тогда <tex>\mathcal{M}[A,c]</tex> содержит номер <tex>i</tex> данной продукции, либо запись об ошибке, и тогда <tex>\mathcal{M}[A,c] = \varnothing</tex>. Если <tex>\mathcal{M}[A,c] \neq \varnothing</tex>, то синтаксический анализатор замещает на стеке нетерминал <tex> A </tex> правой частью правила с номером <tex> i </tex>, помещая символы правила на стек в обратном порядке,
* во всех остальных случаях парсер бросает сообщение об ошибке.

Рассмотренные случаи отображены коротко на картинке справа, где блок <tex> N </tex> отвечает нетерминалам грамматики. Из картинки видно, что вместо рассмотрения всех случаев в коде, достаточно просто создать таблицу <tex>\mathcal{M}</tex> таким образом, чтобы она учитывала все случаи, что упростит код.

=== Псевдокод ===

Здесь по-прежнему <tex>\mathtt{curToken}</tex> обозначает текущий токен строки, а <tex>\mathtt{nextToken}</tex> передвигает указатель на следующий токен.

<code style = "display: inline-block;">
'''function''' nonRecursiveParser():
st : '''Stack'''
st.push(<tex>\perp</tex>)
st.push(<tex>S</tex>) // здесь <tex> S </tex> {{---}} стартовый нетерминал грамматики
'''while''' s.top() <tex>\neq\ \perp</tex>
A = st.top()
'''if''' <tex>\mathcal{M}[A,\ curToken]\ ==\ \mathrm{ok}</tex> // <tex> A\ ==\ \perp </tex> и <tex>\mathtt{curToken}\ ==\ \$</tex>
'''break''' // разбор строки завершён
'''else if''' <tex>\mathcal{M}[A,\ curToken]\ ==\ \nearrow</tex> // выброс
nextToken()
st.pop()
вывести в выходной поток нетерминал, отвечающий <tex>\mathtt{curToken}</tex>
'''else if''' <tex>\mathcal{M}[A,\ curToken]</tex> {{---}} номер правила <tex>A \to \alpha_i,\ \alpha_i = X_1 X_2 \ldots X_t</tex>
st.pop()
'''for''' k = t '''downto''' 1
st.push(<tex>X_k</tex>)
вывести в выходной поток терминал, отвечающий <tex>A</tex>
'''else'''
error("unexpected symbol")
</code>

=== Пример ===

Рассмотрим пример работы нерекурсивного парсера на всё той же грамматике арифметических выражений. Для начала пронумеруем все правила:

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Номер
!style="background-color:#EEE"| Правило
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>1</tex>
|style="background-color:#FFF;padding:2px 10px"| <tex>E \to TE'</tex>
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>2</tex>
|style="background-color:#FFF;padding:2px 10px"| <tex>E' \to +TE'</tex>
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>3</tex>
|style="background-color:#FFF;padding:2px 10px"| <tex>E' \to \varepsilon</tex>
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>4</tex>
|style="background-color:#FFF;padding:2px 10px"| <tex>T \to FT'</tex>
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>5</tex>
|style="background-color:#FFF;padding:2px 10px"| <tex>T' \to * FT'</tex>
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>6</tex>
|style="background-color:#FFF;padding:2px 10px"| <tex>T' \to \varepsilon</tex>
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>7</tex>
|style="background-color:#FFF;padding:2px 10px"| <tex>F \to n</tex>
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>8</tex>
|style="background-color:#FFF;padding:2px 10px"| <tex>F \to (E)</tex>
|}

Теперь можно построить часть таблицы <tex>\mathcal{M}</tex>, содержащей строки, отвечающие нетерминалам. Её построение легко осуществить, если известны <tex>\mathrm{FIRST}</tex> и <tex>\mathrm{FOLLOW}</tex>. По сути по этим множествам можно понять, какое правило использовать для данного нетерминала при текущем токене.

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"|
!style="background-color:#EEE;text-align:center;"| <tex>n</tex>
!style="background-color:#EEE;text-align:center;"| <tex>(</tex>
!style="background-color:#EEE;text-align:center;"| <tex>)</tex>
!style="background-color:#EEE;text-align:center;"| <tex>+</tex>
!style="background-color:#EEE;text-align:center;"| <tex>*</tex>
!style="background-color:#EEE;text-align:center;"| <tex>\$</tex>
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>E</tex>
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>1 </tex>
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>1 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>3 </tex>
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>2 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>3 </tex>
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>T</tex>
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>4 </tex>
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>4 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>6 </tex>
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>6 </tex>
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>5 </tex>
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>6 </tex>
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>F</tex>
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>7 </tex>
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>8 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>\perp</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>\mathrm{ok}</tex>
|}

На картинке ниже показаны состояние стека на нескольких первых итерациях цикла и указатель на текущий токен.

[[Файл:Parse_stack.png|500px]]

== Примечания ==
<references/>
== Источники информации ==
* Альфред Ахо, Рави Сети, Джеффри Ульман. Компиляторы. Принципы, технологии, инструменты. Издательство Вильямс. Второе издание. 2008. Стр. 288 {{---}} 294.

[[Категория: Методы трансляции]]
[[Категория: Нисходящий разбор]]

Предиктивный синтаксический анализ

2015-05-25T12:21:42Z

194.85.160.130: /* Пример */

{{В разработке}}
Для [[LL(k)-грамматики, множества FIRST и FOLLOW | LL(1)-грамматик]] возможна автоматическая генерация парсеров, если известны множества FIRST и FOLLOW. Существуют общедоступные генераторы: ANTLR<ref>[http://www.antlr.org/ ANTLR {{---}} Parser generator]</ref>, Bison<ref>[http://www.gnu.org/software/bison/ Bison {{---}} GNU Project]</ref>, Yacc<ref>[http://dinosaur.compilertools.net/ Lex & Yacc {{---}} A Lexical Analyzer Generator and Yet Another Compiler-Compiler]</ref>, Happy<ref>[https://www.haskell.org/happy/ Happy {{---}} The Parser Generator for Haskell]</ref>.

== Общая схема построения рекурсивных парсеров с помощью FIRST и FOLLOW ==

Пусть <tex>\Gamma =\langle \Sigma, N, S, P \rangle</tex> {{---}} LL(1)-грамматика. Построим для нее парсер.

Для каждого нетерминала <tex>A : A \rightarrow \alpha_1 \mid \alpha_2 \mid \ldots \mid \alpha_k </tex> создадим функцию <tex> \mathtt{A}() : \mathtt{Node} </tex>, возвращающую фрагмент дерева разбора, выведенный из нетерминала <tex>A</tex>.

Здесь <tex>\mathtt{Node}</tex> {{---}} структура следующего вида:
'''struct''' Node
children : '''list<Node>'''
value : '''string''' // имя нетерминала или текст терминала
'''function''' addChild('''Node''') // функция, подвешивающая поддерево к данному узлу

Каждый момент времени парсер работает с определённым '''токеном''' (англ. ''token'') входного слово <tex>s</tex>. Токен {{---}} один или несколько нетерминалов, для удобства объединяемые по смыслу в одну логическую единицы. Примерами токенов могут выступать следующие лексические единицы:
* произвольный символ <tex> c </tex>,
* целое слово, например <tex> public </tex>,
* число со знаком, обозначаемое далее для краткости как <tex> n </tex>.
В общем случае, токеном может являться любое слово, удовлетворяющее произвольному [[Регулярные языки: два определения и их эквивалентность | регулярному выражению]].

[[Файл:string_token.png|300px]]

Здесь <tex>\$</tex> обозначает маркер конца строки.

В псевдокоде используются следующие обозначения:
* <tex>\mathtt{curToken}</tex> {{---}} текущий токен строки,
* <tex>\mathtt{nextToken()}</tex> {{---}} функция, записывающая в <tex>\mathtt{curToken}</tex> следующий за ним токен.

Тогда шаблон функции рекурсивного парсера для нетерминала <tex>A</tex> имеет вид:

A() : '''Node'''
Node res = Node("A")
'''switch''' (curToken) : // принимаем решение в зависимости от текущего токена строки
'''case''' <tex>\mathrm{FIRST}(\alpha_1) \cup (\mathrm{FOLLOW}(A)\ \mathrm{if}\ \varepsilon \in \mathrm{FIRST}(\alpha_1))</tex> :
// <tex>\alpha_1 = X_1X_2 \ldots X_{t}</tex> 
'''for''' i = 1 .. t
'''if''' <tex> X_i </tex> {{---}} нетерминал
consume(<tex>X_i</tex>)
res.addChild(Node("<tex>X_i</tex>")
nextToken()
'''else''' // <tex>X_i</tex> {{---}} терминал, нужно вызвать соответствующую ему функцию рекурсивного парсера 
Node t = <tex>X_i()</tex>
res.addChild(t)
'''break'''
'''case''' <tex>\mathrm{FIRST}(\alpha_2) \cup (\mathrm{FOLLOW}(A)\ \mathrm{if}\ \varepsilon \in \mathrm{FIRST}(\alpha_2))</tex> :
<tex>\ldots</tex>
'''break'''
<tex>\ldots</tex>
'''default''' :
error("unexpected char")
'''return''' res

'''function''' consume(c: '''char''')
'''if''' curToken != c
error("expected " + c)
nextToken()

Такой парсер не только разбирает строку, но и находит ошибки в неудовлетворяющих грамматике выражениях.

== Пример ==
Рассмотрим построение парсера на примере LL(1)-грамматики арифметических выражений, которая уже была разобрана [[Построение FIRST и FOLLOW#Пример | ранее]]:

<tex>
E \to TE' \\
E' \to +TE' \mid \varepsilon \\
T \to FT' \\
T' \to * FT' \mid \varepsilon \\
F \to n \mid (E)
</tex>

Напомним, что множества <tex>\mathrm{FIRST}</tex> и <tex>\mathrm{FOLLOW}</tex> для неё выглядят так:

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Правило
!style="background-color:#EEE"| FIRST
!style="background-color:#EEE"| FOLLOW
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \varepsilon\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ ,\ )\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ *,\ \varepsilon\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ ,\ )\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ *, \ +,\ \$\ ,\ )\ \} </tex>
|}

=== Псевдокоды ===
Построим функции обработки некоторых нетерминалов, используя описанный выше шаблон:

E() : '''Node'''
Node res = Node("E")
'''switch''' (curToken)
'''case''' n, '(' :
res.addChild(T())
res.addChild(E'())
'''break'''
'''default''' :
error("unexpected char")
'''return''' res

E'() : '''Node'''
Node res = Node("E'")
'''switch''' (curToken)
'''case''' '+' :
consume('+')
res.addChild(Node("+"))
res.addChild(T())
res.addChild(E'())
'''break'''
'''case''' '$', ')' :
'''break'''
'''default''' :
error("unexpected char")
'''return''' res

F() : '''Node'''
Node res = Node("F")
'''switch''' (curToken)
'''case''' n :
consume(n)
res.addChild(Node(curToken)) // <tex>\mathtt{curToken}</tex> подпадает под шаблон <tex>n</tex>, поэтому запишем его в <tex>\mathtt{value}</tex> вершины
'''break'''
'''case''' '(' :
consume('(')
res.addChild(Node("("))
res.addChild(E())
consume(')')
res.addChild(Node(")"))
'''default''' :
error("unexpected char")
'''return''' res

Функции для <tex>T</tex> и <tex>T'</tex> строятся аналогично.

=== Дерево разбора ===

Рассмотрим дерево разбора для выражения <tex>(1 + 2) * 3</tex> и несколько первых шагов алгоритма рекурсивного разбора. Сначала вызывается функция стартового нетерминала грамматики, то есть <tex>E</tex>. Так как первым токеном является '(', то будет использовано первое правило разбора <tex>TE'</tex>. Поэтому к вершине с меткой <tex>E</tex> добавятся два ребёнка: <tex>T</tex> и <tex>E'</tex>. А рекурсивный разборщик перейдёт к нетерминалу <tex>T</tex>. По-прежнему curToken равен '(', поэтому в <tex>F</tex> сработает второй case, первым ребёнком добавится '(', curToken станет равен <tex>1</tex>, а разборщик перейдёт к нетерминалу <tex>E</tex>. После того как выражение после '(', которое выводится из <tex>E</tex>, будет полностью разобрано, функция рекурсивного разбора для <tex>F</tex> добавит ')' последним сыном к этому нетерминалу.

Продолжая в том же духе, мы построим всё дерево разбора данного выражения.

[[Файл:parse_ex1.png|400px|thumb|center|Дерево разбора выражения <tex>(1 + 2) * 3</tex>]]

== Нерекурсивный нисходящий парсер ==

[[Файл:Parse_table.png|400px|right]]

Рекурсивные разборщики можно генерировать автоматически, зная множества <tex>\mathrm{FIRST}</tex> и <tex>\mathrm{FOLLOW}</tex>, так как они имеют достаточно прозрачный шаблон построения. Альтернативным способом осуществления нисходящего синтаксического анализа является построение нерекурсивного нисходящего парсера. Его можно построить с помощью явного использования [[Стек | стека]] (вместо неявного при рекурсивных вызовах). Такой анализатор имитирует
[[Контекстно-свободные грамматики, вывод, лево- и правосторонний вывод, дерево разбора#Лево- и правосторонний вывод слова | левое порождение]].

Стек нерекурсивного предиктивного синтаксического анализатора содержит последовательность терминалов и нетерминалов и таблицу синтаксического анализа. На стеке располагается последовательность символов грамматики с маркером конца разбора <tex>\perp</tex> на дне. В начале процесса анализа строки стек содержит стартовый нетерминал грамматики непосредственно над символом <tex>\perp</tex>. Таблица синтаксического анализа представляет собой двухмерный массив <tex>\mathcal{M}[A, c]</tex>, где <tex>A</tex> {{---}} нетерминал или <tex>\perp</tex>, <tex> c </tex> {{---}} токен или символ конца строки <tex>\$</tex>.

Нерекурсивный синтаксический анализатор смотрит на текущий токен <tex> c </tex> входного слова и на символ на вершине стека <tex>A</tex>, а затем принимает решение в зависимости от одного из возникающих ниже случаев:
* если <tex>A\ =\ \perp\ \land\ c\ =\ \$</tex>, то синтаксический анализатор прекращает работу, так как разбор строки завершён,
* eсли <tex>A = c</tex>, то синтаксический анализатор снимает со стека токен <tex>A</tex> и перемещает указатель текущего токена ленты к следующему токену (то есть вызывает <tex>\mathtt{nextToken}</tex>), таким образом, происходит выброс символа <tex> c </tex> со стека,
* eсли <tex>A</tex> представляет собой нетерминал, то программа рассматривает запись <tex>\mathcal{M}[A,c]</tex> таблицы разбора <tex>\mathcal{M}</tex>. Эта запись представляет собой либо продукцию грамматики вида <tex>A \to \alpha_i,\ \alpha_i = X_1 X_2 \ldots X_t</tex>, и тогда <tex>\mathcal{M}[A,c]</tex> содержит номер <tex>i</tex> данной продукции, либо запись об ошибке, и тогда <tex>\mathcal{M}[A,c] = \varnothing</tex>. Если <tex>\mathcal{M}[A,c] \neq \varnothing</tex>, то синтаксический анализатор замещает на стеке нетерминал <tex> A </tex> правой частью правила с номером <tex> i </tex>, помещая символы правила на стек в обратном порядке,
* во всех остальных случаях парсер бросает сообщение об ошибке.

Рассмотренные случаи отображены коротко на картинке справа, где блок <tex> N </tex> отвечает нетерминалам грамматики. Из картинки видно, что вместо рассмотрения всех случаев в коде, достаточно просто создать таблицу <tex>\mathcal{M}</tex> таким образом, чтобы она учитывала все случаи, что упростит код.

=== Псевдокод ===

Здесь по-прежнему <tex>\mathtt{curToken}</tex> обозначает текущий токен строки, а <tex>\mathtt{nextToken}</tex> передвигает указатель на следующий токен.

<code style = "display: inline-block;">
'''function''' nonRecursiveParser():
st : '''Stack'''
st.push(<tex>\perp</tex>)
st.push(<tex>S</tex>) // здесь <tex> S </tex> {{---}} стартовый нетерминал грамматики
'''while''' s.top() <tex>\neq\ \perp</tex>
A = st.top()
'''if''' <tex>\mathcal{M}[A,\ curToken]\ ==\ \mathrm{ok}</tex> // <tex> A\ ==\ \perp </tex> и <tex>\mathtt{curToken}\ ==\ \$</tex>
'''break''' // разбор строки завершён
'''else if''' <tex>\mathcal{M}[A,\ curToken]\ ==\ \nearrow</tex> // выброс
nextToken()
st.pop()
вывести в выходной поток нетерминал, отвечающий <tex>\mathtt{curToken}</tex>
'''else if''' <tex>\mathcal{M}[A,\ curToken]</tex> {{---}} номер правила <tex>A \to \alpha_i,\ \alpha_i = X_1 X_2 \ldots X_t</tex>
st.pop()
'''for''' k = t '''downto''' 1
st.push(<tex>X_k</tex>)
вывести в выходной поток терминал, отвечающий <tex>A</tex>
'''else'''
error("unexpected symbol")
</code>

=== Пример ===

Рассмотрим пример работы нерекурсивного парсера на всё той же грамматике арифметических выражений. Для начала пронумеруем все правила:

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Номер
!style="background-color:#EEE"| Правило
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>1</tex>
|style="background-color:#FFF;padding:2px 10px"| <tex>E \to TE'</tex>
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>2</tex>
|style="background-color:#FFF;padding:2px 10px"| <tex>E' \to +TE'</tex>
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>3</tex>
|style="background-color:#FFF;padding:2px 10px"| <tex>E' \to \varepsilon</tex>
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>4</tex>
|style="background-color:#FFF;padding:2px 10px"| <tex>T \to FT'</tex>
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>5</tex>
|style="background-color:#FFF;padding:2px 10px"| <tex>T' \to * FT'</tex>
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>6</tex>
|style="background-color:#FFF;padding:2px 10px"| <tex>T' \to \varepsilon</tex>
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>7</tex>
|style="background-color:#FFF;padding:2px 10px"| <tex>F \to n</tex>
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>8</tex>
|style="background-color:#FFF;padding:2px 10px"| <tex>F \to (E)</tex>
|}

Теперь можно построить часть таблицы <tex>\mathcal{M}</tex>, содержащей строки, отвечающие нетерминалам. Её построение легко осуществить, если известны <tex>\mathrm{FIRST}</tex> и <tex>\mathrm{FOLLOW}</tex>. По сути по этим множествам можно понять, какое правило использовать для данного нетерминала при текущем токене.

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"|
!style="background-color:#EEE;text-align:center;"| <tex>n</tex>
!style="background-color:#EEE;text-align:center;"| <tex>(</tex>
!style="background-color:#EEE;text-align:center;"| <tex>)</tex>
!style="background-color:#EEE;text-align:center;"| <tex>+</tex>
!style="background-color:#EEE;text-align:center;"| <tex>*</tex>
!style="background-color:#EEE;text-align:center;"| <tex>\$</tex>
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>E</tex>
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>1 </tex>
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>1 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>3 </tex>
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>2 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>3 </tex>
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>T</tex>
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>4 </tex>
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>4 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>6 </tex>
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>6 </tex>
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>5 </tex>
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>6 </tex>
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>F</tex>
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>7 </tex>
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>8 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>\perp</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px;text-align:center;"| <tex>\mathrm{ok}</tex>
|}

На картинке ниже показаны состояние стека на нескольких первых итерациях цикла и указатель на текущий токен.

[[Файл:Parse_stack.png|500px]]

== Примечания ==
<references/>
== Источники информации ==
* Альфред Ахо, Рави Сети, Джеффри Ульман. Компиляторы. Принципы, технологии, инструменты. Издательство Вильямс. Второе издание. 2008. Стр. 288 {{---}} 294.

[[Категория: Методы трансляции]]
[[Категория: Нисходящий разбор]]

Предиктивный синтаксический анализ

2015-05-25T12:06:29Z

194.85.160.130: /* Общая схема построения рекурсивных парсеров с помощью FIRST и FOLLOW */

{{В разработке}}
Для [[LL(k)-грамматики, множества FIRST и FOLLOW | LL(1)-грамматик]] возможна автоматическая генерация парсеров, если известны множества FIRST и FOLLOW. Существуют общедоступные генераторы: ANTLR<ref>[http://www.antlr.org/ ANTLR {{---}} Parser generator]</ref>, Bison<ref>[http://www.gnu.org/software/bison/ Bison {{---}} GNU Project]</ref>, Yacc<ref>[http://dinosaur.compilertools.net/ Lex & Yacc {{---}} A Lexical Analyzer Generator and Yet Another Compiler-Compiler]</ref>, Happy<ref>[https://www.haskell.org/happy/ Happy {{---}} The Parser Generator for Haskell]</ref>.

== Общая схема построения рекурсивных парсеров с помощью FIRST и FOLLOW ==

Пусть <tex>\Gamma =\langle \Sigma, N, S, P \rangle</tex> {{---}} LL(1)-грамматика. Построим для нее парсер.

Для каждого нетерминала <tex>A : A \rightarrow \alpha_1 \mid \alpha_2 \mid \ldots \mid \alpha_k </tex> создадим функцию <tex> \mathtt{A}() : \mathtt{Node} </tex>, возвращающую фрагмент дерева разбора, выведенный из нетерминала <tex>A</tex>.

Здесь <tex>\mathtt{Node}</tex> {{---}} структура следующего вида:
'''struct''' Node
children : '''list<Node>'''
value : '''string''' // имя нетерминала или текст терминала
'''function''' addChild('''Node''') // функция, подвешивающая поддерево к данному узлу

Каждый момент времени парсер работает с определённым '''токеном''' (англ. ''token'') входного слово <tex>s</tex>. Токен {{---}} один или несколько нетерминалов, для удобства объединяемые по смыслу в одну логическую единицы. Примерами токенов могут выступать следующие лексические единицы:
* произвольный символ <tex> c </tex>,
* целое слово, например <tex> public </tex>,
* число со знаком, обозначаемое далее для краткости как <tex> n </tex>.
В общем случае, токеном может являться любое слово, удовлетворяющее произвольному [[Регулярные языки: два определения и их эквивалентность | регулярному выражению]].

[[Файл:string_token.png|300px]]

Здесь <tex>\$</tex> обозначает маркер конца строки.

В псевдокоде используются следующие обозначения:
* <tex>\mathtt{curToken}</tex> {{---}} текущий токен строки,
* <tex>\mathtt{nextToken()}</tex> {{---}} функция, записывающая в <tex>\mathtt{curToken}</tex> следующий за ним токен.

Тогда шаблон функции рекурсивного парсера для нетерминала <tex>A</tex> имеет вид:

A() : '''Node'''
Node res = Node("A")
'''switch''' (curToken) : // принимаем решение в зависимости от текущего токена строки
'''case''' <tex>\mathrm{FIRST}(\alpha_1) \cup (\mathrm{FOLLOW}(A)\ \mathrm{if}\ \varepsilon \in \mathrm{FIRST}(\alpha_1))</tex> :
// <tex>\alpha_1 = X_1X_2 \ldots X_{t}</tex> 
'''for''' i = 1 .. t
'''if''' <tex> X_i </tex> {{---}} нетерминал
consume(<tex>X_i</tex>)
res.addChild(Node("<tex>X_i</tex>")
nextToken()
'''else''' // <tex>X_i</tex> {{---}} терминал, нужно вызвать соответствующую ему функцию рекурсивного парсера 
Node t = <tex>X_i()</tex>
res.addChild(t)
'''break'''
'''case''' <tex>\mathrm{FIRST}(\alpha_2) \cup (\mathrm{FOLLOW}(A)\ \mathrm{if}\ \varepsilon \in \mathrm{FIRST}(\alpha_2))</tex> :
<tex>\ldots</tex>
'''break'''
<tex>\ldots</tex>
'''default''' :
error("unexpected char")
'''return''' res

'''function''' consume(c: '''char''')
'''if''' curToken != c
error("expected " + c)
nextToken()

Такой парсер не только разбирает строку, но и находит ошибки в неудовлетворяющих грамматике выражениях.

== Пример ==
Рассмотрим построение парсера на примере LL(1)-грамматики арифметических выражений, которая уже была разобрана [[Построение FIRST и FOLLOW#Пример | ранее]]:

<tex>
E \to TE' \\
E' \to +TE' \mid \varepsilon \\
T \to FT' \\
T' \to * FT' \mid \varepsilon \\
F \to n \mid (E)
</tex>

Напомним, что множества <tex>\mathrm{FIRST}</tex> и <tex>\mathrm{FOLLOW}</tex> для неё выглядят так:

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Правило
!style="background-color:#EEE"| FIRST
!style="background-color:#EEE"| FOLLOW
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \varepsilon\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ ,\ )\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ *,\ \varepsilon\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ ,\ )\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ *, \ +,\ \$\ ,\ )\ \} </tex>
|}

=== Псевдокоды ===
Построим функции обработки некоторых нетерминалов, используя описанный выше шаблон:

E() : '''Node'''
Node res = Node("E")
'''switch''' (curToken)
'''case''' n, '(' :
res.addChild(T())
res.addChild(E'())
'''break'''
'''default''' :
error("unexpected char")
'''return''' res

E'() : '''Node'''
Node res = Node("E'")
'''switch''' (curToken)
'''case''' '+' :
consume('+')
res.addChild(Node("+"))
res.addChild(T())
res.addChild(E'())
'''break'''
'''case''' '$', ')' :
'''break'''
'''default''' :
error("unexpected char")
'''return''' res

F() : '''Node'''
Node res = Node("F")
'''switch''' (curToken)
'''case''' n :
consume(n)
res.addChild(Node(curToken)) // <tex>\mathtt{curToken}</tex> подпадает под шаблон <tex>n</tex>, поэтому запишем его в <tex>\mathtt{value}</tex> вершины
'''break'''
'''case''' '(' :
consume('(')
res.addChild(Node("("))
res.addChild(E())
consume(')')
res.addChild(Node(")"))
'''default''' :
error("unexpected char")
'''return''' res

Функции для <tex>T</tex> и <tex>T'</tex> строятся аналогично.

=== Дерево разбора ===

Рассмотрим дерево разбора для выражения <tex>(1 + 2) * 3</tex> и несколько первых шагов алгоритма рекурсивного разбора. Сначала вызывается функция стартового нетерминала грамматики, то есть <tex>E</tex>. Так как первым токеном является '(', то будет использовано первое правило разбора <tex>TE'</tex>. Поэтому к вершине с меткой <tex>E</tex> добавятся два ребёнка: <tex>T</tex> и <tex>E'</tex>. А рекурсивный разборщик перейдёт к нетерминалу <tex>T</tex>. По-прежнему curToken равен '(', поэтому в <tex>F</tex> сработает второй case, первым ребёнком добавится '(', curToken станет равен <tex>1</tex>, а разборщик перейдёт к нетерминалу <tex>E</tex>. После того как выражение после '(', которое выводится из <tex>E</tex>, будет полностью разобрано, функция рекурсивного разбора для <tex>F</tex> добавит ')' последним сыном к этому нетерминалу.

Продолжая в том же духе, мы построим всё дерево разбора данного выражения.

[[Файл:parse_ex1.png|400px|thumb|center|Дерево разбора выражения <tex>(1 + 2) * 3</tex>]]

== Нерекурсивный нисходящий парсер ==

[[Файл:Parse_table.png|400px|right]]

Рекурсивные разборщики можно генерировать автоматически, зная множества <tex>\mathrm{FIRST}</tex> и <tex>\mathrm{FOLLOW}</tex>, так как они имеют достаточно прозрачный шаблон построения. Альтернативным способом осуществления нисходящего синтаксического анализа является построение нерекурсивного нисходящего парсера. Его можно построить с помощью явного использования [[Стек | стека]] (вместо неявного при рекурсивных вызовах). Такой анализатор имитирует
[[Контекстно-свободные грамматики, вывод, лево- и правосторонний вывод, дерево разбора#Лево- и правосторонний вывод слова | левое порождение]].

Стек нерекурсивного предиктивного синтаксического анализатора содержит последовательность терминалов и нетерминалов и таблицу синтаксического анализа. На стеке располагается последовательность символов грамматики с маркером конца разбора <tex>\perp</tex> на дне. В начале процесса анализа строки стек содержит стартовый нетерминал грамматики непосредственно над символом <tex>\perp</tex>. Таблица синтаксического анализа представляет собой двухмерный массив <tex>\mathcal{M}[A, c]</tex>, где <tex>A</tex> {{---}} нетерминал или <tex>\perp</tex>, <tex> c </tex> {{---}} токен или символ конца строки <tex>\$</tex>.

Нерекурсивный синтаксический анализатор смотрит на текущий токен <tex> c </tex> входного слова и на символ на вершине стека <tex>A</tex>, а затем принимает решение в зависимости от одного из возникающих ниже случаев:
* если <tex>A\ =\ \perp\ \land\ c\ =\ \$</tex>, то синтаксический анализатор прекращает работу, так как разбор строки завершён,
* eсли <tex>A = c</tex>, то синтаксический анализатор снимает со стека токен <tex>A</tex> и перемещает указатель текущего токена ленты к следующему токену (то есть вызывает <tex>\mathtt{nextToken}</tex>), таким образом, происходит выброс символа <tex> c </tex> со стека,
* eсли <tex>A</tex> представляет собой нетерминал, то программа рассматривает запись <tex>\mathcal{M}[A,c]</tex> таблицы разбора <tex>\mathcal{M}</tex>. Эта запись представляет собой либо продукцию грамматики вида <tex>A \to \alpha_i,\ \alpha_i = X_1 X_2 \ldots X_t</tex>, и тогда <tex>\mathcal{M}[A,c]</tex> содержит номер <tex>i</tex> данной продукции, либо запись об ошибке, и тогда <tex>\mathcal{M}[A,c] = \varnothing</tex>. Если <tex>\mathcal{M}[A,c] \neq \varnothing</tex>, то синтаксический анализатор замещает на стеке нетерминал <tex> A </tex> правой частью правила с номером <tex> i </tex>, помещая символы правила на стек в обратном порядке,
* во всех остальных случаях парсер бросает сообщение об ошибке.

Рассмотренные случаи отображены коротко на картинке справа, где блок <tex> N </tex> отвечает нетерминалам грамматики. Из картинки видно, что вместо рассмотрения всех случаев в коде, достаточно просто создать таблицу <tex>\mathcal{M}</tex> таким образом, чтобы она учитывала все случаи, что упростит код.

=== Псевдокод ===

Здесь по-прежнему <tex>\mathtt{curToken}</tex> обозначает текущий токен строки, а <tex>\mathtt{nextToken}</tex> передвигает указатель на следующий токен.

<code style = "display: inline-block;">
'''function''' nonRecursiveParser():
st : '''Stack'''
st.push(<tex>\perp</tex>)
st.push(<tex>S</tex>) // здесь <tex> S </tex> {{---}} стартовый нетерминал грамматики
'''while''' s.top() <tex>\neq\ \perp</tex>
A = st.top()
'''if''' <tex>\mathcal{M}[A,\ curToken]\ ==\ \mathrm{ok}</tex> // <tex> A\ ==\ \perp </tex> и <tex>\mathtt{curToken}\ ==\ \$</tex>
'''break''' // разбор строки завершён
'''else if''' <tex>\mathcal{M}[A,\ curToken]\ ==\ \nearrow</tex> // выброс
nextToken()
st.pop()
вывести в выходной поток нетерминал, отвечающий <tex>\mathtt{curToken}</tex>
'''else if''' <tex>\mathcal{M}[A,\ curToken]</tex> {{---}} номер правила <tex>A \to \alpha_i,\ \alpha_i = X_1 X_2 \ldots X_t</tex>
st.pop()
'''for''' k = t '''downto''' 1
st.push(<tex>X_k</tex>)
вывести в выходной поток терминал, отвечающий <tex>A</tex>
'''else'''
error("unexpected symbol")
</code>

=== Пример ===

<tex>
(1) \ E \to TE' \\
(2) \ E' \to +TE' \\
(3) \ E' \to \varepsilon \\
(4) \ T \to FT' \\
(5) \ T' \to \times FT' \\
(6) \ T' \to \varepsilon \\
(7) \ F \to n \\
(8) \ F \to (E)
</tex>

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"|
!style="background-color:#EEE"| n
!style="background-color:#EEE"| (
!style="background-color:#EEE"| )
!style="background-color:#EEE"| +
!style="background-color:#EEE"| *
!style="background-color:#EEE"| $
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>1 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"| <tex>3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>2 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"| <tex>3 </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>4 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"| <tex>6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>6 </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>8 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>\perp</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|}

[[Файл:Parse_stack.png|500px]]

== Примечания ==
<references/>
== Источники информации ==
* Альфред Ахо, Рави Сети, Джеффри Ульман. Компиляторы. Принципы, технологии, инструменты. Издательство Вильямс. Второе издание. 2008. Стр. 288 {{---}} 294.

[[Категория: Методы трансляции]]
[[Категория: Нисходящий разбор]]

Предиктивный синтаксический анализ

2015-05-25T11:59:47Z

194.85.160.130: /* Нерекурсивный нисходящий парсер */

{{В разработке}}
Для [[LL(k)-грамматики, множества FIRST и FOLLOW | LL(1)-грамматик]] возможна автоматическая генерация парсеров, если известны множества FIRST и FOLLOW. Существуют общедоступные генераторы: ANTLR<ref>[http://www.antlr.org/ ANTLR {{---}} Parser generator]</ref>, Bison<ref>[http://www.gnu.org/software/bison/ Bison {{---}} GNU Project]</ref>, Yacc<ref>[http://dinosaur.compilertools.net/ Lex & Yacc {{---}} A Lexical Analyzer Generator and Yet Another Compiler-Compiler]</ref>, Happy<ref>[https://www.haskell.org/happy/ Happy {{---}} The Parser Generator for Haskell]</ref>.

== Общая схема построения рекурсивных парсеров с помощью FIRST и FOLLOW ==

Пусть <tex>\Gamma =\langle \Sigma, N, S, P \rangle</tex> {{---}} LL(1)-грамматика. Построим для нее парсер.

Для каждого нетерминала <tex>A : A \rightarrow \alpha_1 \mid \alpha_2 \mid \ldots \mid \alpha_k </tex> создадим функцию <tex> \mathtt{A}() : \mathtt{Node} </tex>, возвращающую фрагмент дерева разбора, выведенный из нетерминала <tex>A</tex>.

Здесь <tex>\mathtt{Node}</tex> {{---}} структура следующего вида:
'''struct''' Node
children : '''list<Node>'''
value : '''string''' // имя нетерминала или текст терминала
'''function''' addChild('''Node''') // функция, подвешивающая поддерево к данному узлу

Каждый момент времени парсер работает с определённым '''токеном''' (англ. ''token'') входного слово <tex>s</tex>. Токен {{---}} один или несколько нетерминалов, для удобства объединяемые по смыслу в одну логическую единицы. Примерами токенов могут выступать следующие лексические единицы:
* произвольный символ <tex> c </tex>,
* целое слово, например <tex> public </tex>,
* число со знаком, обозначаемое далее для краткости как <tex> n </tex>.
В общем случае, токеном может являться любое слово, удовлетворяющее произвольному [[Регулярные языки: два определения и их эквивалентность | регулярному выражению]].

[[Файл:string_token.png|300px]]

Здесь <tex>\$</tex> обозначает маркер конца строки.

В псевдокоде используются следующие обозначения:
* <tex>\mathtt{curToken}</tex> {{---}} текущий токен строки,
* <tex>\mathtt{nextToken()}</tex> {{---}} функция, записывающая в <tex>\mathtt{curToken}</tex> следующий за ним токен.

Тогда шаблон функции рекурсивного парсера для нетерминала <tex>A</tex> имеет вид:

A() : '''Node'''
Node res = Node("A")
'''switch''' (curToken) : // принимаем решение в зависимости от текущего токена строки
'''case''' <tex>\mathrm{FIRST}(\alpha_1) \cup (\mathrm{FOLLOW}(A)\ \mathrm{if}\ \varepsilon \in \mathrm{FIRST}(\alpha_1))</tex> :
// <tex>\alpha_1 = X_1X_2 \ldots X_{t}</tex> 
'''for''' i = 1 .. t
'''if''' <tex> X_i </tex> {{---}} нетерминал
consume(<tex>X_i</tex>)
res.addChild(Node("<tex>X_i</tex>")
nextToken()
'''else''' // <tex>X_i</tex> {{---}} терминал, нужно вызвать соответствующую ему функцию рекурсивного парсера 
Node t = <tex>X_i()</tex>
res.addChild(t)
'''break'''
'''case''' <tex>\mathrm{FIRST}(\alpha_2) \cup (\mathrm{FOLLOW}(A)\ \mathrm{if}\ \varepsilon \in \mathrm{FIRST}(\alpha_2))</tex> :
...
'''break'''
...
'''default''' :
error("unexpected char")
'''return''' res

'''function''' consume(c: '''char''')
'''if''' curToken != c
error("expected " + c)
nextToken()

Такой парсер не только разбирает строку, но и находит ошибки в неудовлетворяющих грамматике выражениях.

== Пример ==
Рассмотрим построение парсера на примере LL(1)-грамматики арифметических выражений, которая уже была разобрана [[Построение FIRST и FOLLOW#Пример | ранее]]:

<tex>
E \to TE' \\
E' \to +TE' \mid \varepsilon \\
T \to FT' \\
T' \to * FT' \mid \varepsilon \\
F \to n \mid (E)
</tex>

Напомним, что множества <tex>\mathrm{FIRST}</tex> и <tex>\mathrm{FOLLOW}</tex> для неё выглядят так:

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Правило
!style="background-color:#EEE"| FIRST
!style="background-color:#EEE"| FOLLOW
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \varepsilon\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ ,\ )\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ *,\ \varepsilon\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ ,\ )\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ *, \ +,\ \$\ ,\ )\ \} </tex>
|}

=== Псевдокоды ===
Построим функции обработки некоторых нетерминалов, используя описанный выше шаблон:

E() : '''Node'''
Node res = Node("E")
'''switch''' (curToken)
'''case''' n, '(' :
res.addChild(T())
res.addChild(E'())
'''break'''
'''default''' :
error("unexpected char")
'''return''' res

E'() : '''Node'''
Node res = Node("E'")
'''switch''' (curToken)
'''case''' '+' :
consume('+')
res.addChild(Node("+"))
res.addChild(T())
res.addChild(E'())
'''break'''
'''case''' '$', ')' :
'''break'''
'''default''' :
error("unexpected char")
'''return''' res

F() : '''Node'''
Node res = Node("F")
'''switch''' (curToken)
'''case''' n :
consume(n)
res.addChild(Node(curToken)) // <tex>\mathtt{curToken}</tex> подпадает под шаблон <tex>n</tex>, поэтому запишем его в <tex>\mathtt{value}</tex> вершины
'''break'''
'''case''' '(' :
consume('(')
res.addChild(Node("("))
res.addChild(E())
consume(')')
res.addChild(Node(")"))
'''default''' :
error("unexpected char")
'''return''' res

Функции для <tex>T</tex> и <tex>T'</tex> строятся аналогично.

=== Дерево разбора ===

Рассмотрим дерево разбора для выражения <tex>(1 + 2) * 3</tex> и несколько первых шагов алгоритма рекурсивного разбора. Сначала вызывается функция стартового нетерминала грамматики, то есть <tex>E</tex>. Так как первым токеном является '(', то будет использовано первое правило разбора <tex>TE'</tex>. Поэтому к вершине с меткой <tex>E</tex> добавятся два ребёнка: <tex>T</tex> и <tex>E'</tex>. А рекурсивный разборщик перейдёт к нетерминалу <tex>T</tex>. По-прежнему curToken равен '(', поэтому в <tex>F</tex> сработает второй case, первым ребёнком добавится '(', curToken станет равен <tex>1</tex>, а разборщик перейдёт к нетерминалу <tex>E</tex>. После того как выражение после '(', которое выводится из <tex>E</tex>, будет полностью разобрано, функция рекурсивного разбора для <tex>F</tex> добавит ')' последним сыном к этому нетерминалу.

Продолжая в том же духе, мы построим всё дерево разбора данного выражения.

[[Файл:parse_ex1.png|400px|thumb|center|Дерево разбора выражения <tex>(1 + 2) * 3</tex>]]

== Нерекурсивный нисходящий парсер ==

[[Файл:Parse_table.png|400px|right]]

Рекурсивные разборщики можно генерировать автоматически, зная множества <tex>\mathrm{FIRST}</tex> и <tex>\mathrm{FOLLOW}</tex>, так как они имеют достаточно прозрачный шаблон построения. Альтернативным способом осуществления нисходящего синтаксического анализа является построение нерекурсивного нисходящего парсера. Его можно построить с помощью явного использования [[Стек | стека]] (вместо неявного при рекурсивных вызовах). Такой анализатор имитирует
[[Контекстно-свободные грамматики, вывод, лево- и правосторонний вывод, дерево разбора#Лево- и правосторонний вывод слова | левое порождение]].

Стек нерекурсивного предиктивного синтаксического анализатора содержит последовательность терминалов и нетерминалов и таблицу синтаксического анализа. На стеке располагается последовательность символов грамматики с маркером конца разбора <tex>\perp</tex> на дне. В начале процесса анализа строки стек содержит стартовый нетерминал грамматики непосредственно над символом <tex>\perp</tex>. Таблица синтаксического анализа представляет собой двухмерный массив <tex>\mathcal{M}[A, c]</tex>, где <tex>A</tex> {{---}} нетерминал или <tex>\perp</tex>, <tex> c </tex> {{---}} токен или символ конца строки <tex>\$</tex>.

Нерекурсивный синтаксический анализатор смотрит на текущий токен <tex> c </tex> входного слова и на символ на вершине стека <tex>A</tex>, а затем принимает решение в зависимости от одного из возникающих ниже случаев:
* если <tex>A\ =\ \perp\ \land\ c\ =\ \$</tex>, то синтаксический анализатор прекращает работу, так как разбор строки завершён,
* eсли <tex>A = c</tex>, то синтаксический анализатор снимает со стека токен <tex>A</tex> и перемещает указатель текущего токена ленты к следующему токену (то есть вызывает <tex>\mathtt{nextToken}</tex>), таким образом, происходит выброс символа <tex> c </tex> со стека,
* eсли <tex>A</tex> представляет собой нетерминал, то программа рассматривает запись <tex>\mathcal{M}[A,c]</tex> таблицы разбора <tex>\mathcal{M}</tex>. Эта запись представляет собой либо продукцию грамматики вида <tex>A \to \alpha_i,\ \alpha_i = X_1 X_2 \ldots X_t</tex>, и тогда <tex>\mathcal{M}[A,c]</tex> содержит номер <tex>i</tex> данной продукции, либо запись об ошибке, и тогда <tex>\mathcal{M}[A,c] = \varnothing</tex>. Если <tex>\mathcal{M}[A,c] \neq \varnothing</tex>, то синтаксический анализатор замещает на стеке нетерминал <tex> A </tex> правой частью правила с номером <tex> i </tex>, помещая символы правила на стек в обратном порядке,
* во всех остальных случаях парсер бросает сообщение об ошибке.

Рассмотренные случаи отображены коротко на картинке справа, где блок <tex> N </tex> отвечает нетерминалам грамматики. Из картинки видно, что вместо рассмотрения всех случаев в коде, достаточно просто создать таблицу <tex>\mathcal{M}</tex> таким образом, чтобы она учитывала все случаи, что упростит код.

=== Псевдокод ===

Здесь по-прежнему <tex>\mathtt{curToken}</tex> обозначает текущий токен строки, а <tex>\mathtt{nextToken}</tex> передвигает указатель на следующий токен.

<code style = "display: inline-block;">
'''function''' nonRecursiveParser():
st : '''Stack'''
st.push(<tex>\perp</tex>)
st.push(<tex>S</tex>) // здесь <tex> S </tex> {{---}} стартовый нетерминал грамматики
'''while''' s.top() <tex>\neq\ \perp</tex>
A = st.top()
'''if''' <tex>\mathcal{M}[A,\ curToken]\ ==\ \mathrm{ok}</tex> // <tex> A\ ==\ \perp </tex> и <tex>\mathtt{curToken}\ ==\ \$</tex>
'''break''' // разбор строки завершён
'''else if''' <tex>\mathcal{M}[A,\ curToken]\ ==\ \nearrow</tex> // выброс
nextToken()
st.pop()
вывести в выходной поток нетерминал, отвечающий <tex>\mathtt{curToken}</tex>
'''else if''' <tex>\mathcal{M}[A,\ curToken]</tex> {{---}} номер правила <tex>A \to \alpha_i,\ \alpha_i = X_1 X_2 \ldots X_t</tex>
st.pop()
'''for''' k = t '''downto''' 1
st.push(<tex>X_k</tex>)
вывести в выходной поток терминал, отвечающий <tex>A</tex>
'''else'''
error("unexpected symbol")
</code>

=== Пример ===

<tex>
(1) \ E \to TE' \\
(2) \ E' \to +TE' \\
(3) \ E' \to \varepsilon \\
(4) \ T \to FT' \\
(5) \ T' \to \times FT' \\
(6) \ T' \to \varepsilon \\
(7) \ F \to n \\
(8) \ F \to (E)
</tex>

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"|
!style="background-color:#EEE"| n
!style="background-color:#EEE"| (
!style="background-color:#EEE"| )
!style="background-color:#EEE"| +
!style="background-color:#EEE"| *
!style="background-color:#EEE"| $
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>1 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"| <tex>3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>2 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"| <tex>3 </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>4 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"| <tex>6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>6 </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>8 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>\perp</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|}

[[Файл:Parse_stack.png|500px]]

== Примечания ==
<references/>
== Источники информации ==
* Альфред Ахо, Рави Сети, Джеффри Ульман. Компиляторы. Принципы, технологии, инструменты. Издательство Вильямс. Второе издание. 2008. Стр. 288 {{---}} 294.

[[Категория: Методы трансляции]]
[[Категория: Нисходящий разбор]]

Предиктивный синтаксический анализ

2015-05-25T11:09:51Z

194.85.160.130: /* Общая схема построения рекурсивных парсеров с помощью FIRST и FOLLOW */

{{В разработке}}
Для [[LL(k)-грамматики, множества FIRST и FOLLOW | LL(1)-грамматик]] возможна автоматическая генерация парсеров, если известны множества FIRST и FOLLOW. Существуют общедоступные генераторы: ANTLR<ref>[http://www.antlr.org/ ANTLR {{---}} Parser generator]</ref>, Bison<ref>[http://www.gnu.org/software/bison/ Bison {{---}} GNU Project]</ref>, Yacc<ref>[http://dinosaur.compilertools.net/ Lex & Yacc {{---}} A Lexical Analyzer Generator and Yet Another Compiler-Compiler]</ref>, Happy<ref>[https://www.haskell.org/happy/ Happy {{---}} The Parser Generator for Haskell]</ref>.

== Общая схема построения рекурсивных парсеров с помощью FIRST и FOLLOW ==

Пусть <tex>\Gamma =\langle \Sigma, N, S, P \rangle</tex> {{---}} LL(1)-грамматика. Построим для нее парсер.

Для каждого нетерминала <tex>A : A \rightarrow \alpha_1 \mid \alpha_2 \mid \ldots \mid \alpha_k </tex> создадим функцию <tex> \mathtt{A}() : \mathtt{Node} </tex>, возвращающую фрагмент дерева разбора, выведенный из нетерминала <tex>A</tex>.

Здесь <tex>\mathtt{Node}</tex> {{---}} структура следующего вида:
'''struct''' Node
children : '''list<Node>'''
value : '''string''' // имя нетерминала или текст терминала
'''function''' addChild('''Node''') // функция, подвешивающая поддерево к данному узлу

Каждый момент времени парсер работает с определённым '''токеном''' (англ. ''token'') входного слово <tex>s</tex>. Токен {{---}} один или несколько нетерминалов, для удобства объединяемые по смыслу в одну логическую единицы. Примерами токенов могут выступать следующие лексические единицы:
* произвольный символ <tex> c </tex>,
* целое слово, например <tex> public </tex>,
* число со знаком, обозначаемое далее для краткости как <tex> n </tex>.
В общем случае, токеном может являться любое слово, удовлетворяющее произвольному [[Регулярные языки: два определения и их эквивалентность | регулярному выражению]].

[[Файл:string_token.png|300px]]

Здесь <tex>\$</tex> обозначает маркер конца строки.

В псевдокоде используются следующие обозначения:
* <tex>\mathtt{curToken}</tex> {{---}} текущий токен строки,
* <tex>\mathtt{nextToken()}</tex> {{---}} функция, записывающая в <tex>\mathtt{curToken}</tex> следующий за ним токен.

Тогда шаблон функции рекурсивного парсера для нетерминала <tex>A</tex> имеет вид:

A() : '''Node'''
Node res = Node("A")
'''switch''' (curToken) : // принимаем решение в зависимости от текущего токена строки
'''case''' <tex>\mathrm{FIRST}(\alpha_1) \cup (\mathrm{FOLLOW}(A)\ \mathrm{if}\ \varepsilon \in \mathrm{FIRST}(\alpha_1))</tex> :
// <tex>\alpha_1 = X_1X_2 \ldots X_{t}</tex> 
'''for''' i = 1 .. t
'''if''' <tex> X_i </tex> {{---}} нетерминал
consume(<tex>X_i</tex>)
res.addChild(Node("<tex>X_i</tex>")
nextToken()
'''else''' // <tex>X_i</tex> {{---}} терминал, нужно вызвать соответствующую ему функцию рекурсивного парсера 
Node t = <tex>X_i()</tex>
res.addChild(t)
'''break'''
'''case''' <tex>\mathrm{FIRST}(\alpha_2) \cup (\mathrm{FOLLOW}(A)\ \mathrm{if}\ \varepsilon \in \mathrm{FIRST}(\alpha_2))</tex> :
...
'''break'''
...
'''default''' :
error("unexpected char")
'''return''' res

'''function''' consume(c: '''char''')
'''if''' curToken != c
error("expected " + c)
nextToken()

Такой парсер не только разбирает строку, но и находит ошибки в неудовлетворяющих грамматике выражениях.

== Пример ==
Рассмотрим построение парсера на примере LL(1)-грамматики арифметических выражений, которая уже была разобрана [[Построение FIRST и FOLLOW#Пример | ранее]]:

<tex>
E \to TE' \\
E' \to +TE' \mid \varepsilon \\
T \to FT' \\
T' \to * FT' \mid \varepsilon \\
F \to n \mid (E)
</tex>

Напомним, что множества <tex>\mathrm{FIRST}</tex> и <tex>\mathrm{FOLLOW}</tex> для неё выглядят так:

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Правило
!style="background-color:#EEE"| FIRST
!style="background-color:#EEE"| FOLLOW
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \varepsilon\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ ,\ )\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ *,\ \varepsilon\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ ,\ )\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ *, \ +,\ \$\ ,\ )\ \} </tex>
|}

=== Псевдокоды ===
Построим функции обработки некоторых нетерминалов, используя описанный выше шаблон:

E() : '''Node'''
Node res = Node("E")
'''switch''' (curToken)
'''case''' n, '(' :
res.addChild(T())
res.addChild(E'())
'''break'''
'''default''' :
error("unexpected char")
'''return''' res

E'() : '''Node'''
Node res = Node("E'")
'''switch''' (curToken)
'''case''' '+' :
consume('+')
res.addChild(Node("+"))
res.addChild(T())
res.addChild(E'())
'''break'''
'''case''' '$', ')' :
'''break'''
'''default''' :
error("unexpected char")
'''return''' res

F() : '''Node'''
Node res = Node("F")
'''switch''' (curToken)
'''case''' n :
consume(n)
res.addChild(Node(curToken)) // <tex>\mathtt{curToken}</tex> подпадает под шаблон <tex>n</tex>, поэтому запишем его в <tex>\mathtt{value}</tex> вершины
'''break'''
'''case''' '(' :
consume('(')
res.addChild(Node("("))
res.addChild(E())
consume(')')
res.addChild(Node(")"))
'''default''' :
error("unexpected char")
'''return''' res

Функции для <tex>T</tex> и <tex>T'</tex> строятся аналогично.

=== Дерево разбора ===

Рассмотрим дерево разбора для выражения <tex>(1 + 2) * 3</tex> и несколько первых шагов алгоритма рекурсивного разбора. Сначала вызывается функция стартового нетерминала грамматики, то есть <tex>E</tex>. Так как первым токеном является '(', то будет использовано первое правило разбора <tex>TE'</tex>. Поэтому к вершине с меткой <tex>E</tex> добавятся два ребёнка: <tex>T</tex> и <tex>E'</tex>. А рекурсивный разборщик перейдёт к нетерминалу <tex>T</tex>. По-прежнему curToken равен '(', поэтому в <tex>F</tex> сработает второй case, первым ребёнком добавится '(', curToken станет равен <tex>1</tex>, а разборщик перейдёт к нетерминалу <tex>E</tex>. После того как выражение после '(', которое выводится из <tex>E</tex>, будет полностью разобрано, функция рекурсивного разбора для <tex>F</tex> добавит ')' последним сыном к этому нетерминалу.

Продолжая в том же духе, мы построим всё дерево разбора данного выражения.

[[Файл:parse_ex1.png|400px|thumb|center|Дерево разбора выражения <tex>(1 + 2) * 3</tex>]]

== Нерекурсивный нисходящий парсер ==

[[Файл:Parse_table.png|400px|right]]

Рекурсивные разборщики можно генерировать автоматически, зная множества FIRST и FOLLOW, так как они имеют достаточно прозрачный шаблон построения. Альтернативным способом осуществления нисходящего синтаксического анализа является построение нерекурсивного нисходящего парсера. Его можно построить с помощью явного использования стека (вместо неявного при рекурсивных вызовах). Такое анализатор имитирует левое порождение.

Нерекурсивный предиктивный синтаксический анализатор содержит дополнительно стек, содержащий последовательность терминалов и нетерминалов, и таблицу синтаксического анализа. На стеке располагается последовательность символов грамматики с маркером конца строки $ на дне. В начале процесса анализа строки стек содержит стартовый нетерминал грамматики непосредственно над символом $. Таблица синтаксического анализа представляет собой двухмерный массив М[X, а], где X — нетерминал, а — терминал или символ $.

Нерекурсивный синтаксический анализатор смотрит на текущий токен строки a и на символ на вершине стека X, а затем принимает решение в зависимости от одного из возникающих ниже случаев:
* если Х=curToken=$, синтаксический анализатор прекращает работу, так как разбор строки завершён,
* eсли Х=curToken≠$, синтаксический анализатор снимает со стека X и перемещает указатель входного потока к следующему токену (то есть вызывает nextToken),
* eсли X представляет собой нетерминал, программа рассматривает запись M[Х,а] таблицы разбора М. Эта запись представляет собой либо X-продукцию грамматики, либо запись об ошибке. Если, например, М[Х,а] = {X → UVW}, синтаксический анализатор замещает X на вершине стека на WVU (с U на вершине стека). В кач-ве выхода синтаксический анализатор просто выводит использованную продукцию. Если M[Х,а] = error, синтаксический анализатор вызывает программу восстановления после ошибки.

=== Псевдокод ===
<code style = "display: inline-block;">
function nonRecursiveParser(w : String):
s : Stack
s.push(bottom)
s.push(Start)
do
X = s.top()
if X == c
c = nextToken()
s.pop()
else if X in Sigma
error("unexpected symbol")
else if M[X, c] == undefined // запись об ошибке
error("unexpected symbol")
else if M[X, c] == X -> Y_1 Y_2 ... Y_k
s.pop()
for i = k downto 1
s.push(Y_i)
while s.top() != bottom
</code>

=== Пример ===

<tex>
(1) \ E \to TE' \\
(2) \ E' \to +TE' \\
(3) \ E' \to \varepsilon \\
(4) \ T \to FT' \\
(5) \ T' \to \times FT' \\
(6) \ T' \to \varepsilon \\
(7) \ F \to n \\
(8) \ F \to (E)
</tex>

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"|
!style="background-color:#EEE"| n
!style="background-color:#EEE"| (
!style="background-color:#EEE"| )
!style="background-color:#EEE"| +
!style="background-color:#EEE"| *
!style="background-color:#EEE"| $
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>1 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"| <tex>3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>2 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"| <tex>3 </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>4 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"| <tex>6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>6 </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>8 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>\perp</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|}

[[Файл:Parse_stack.png|500px]]

== Примечания ==
<references/>
== Источники информации ==
* Альфред Ахо, Рави Сети, Джеффри Ульман. Компиляторы. Принципы, технологии, инструменты. Издательство Вильямс. Второе издание. 2008. Стр. 288 {{---}} 294.

[[Категория: Методы трансляции]]
[[Категория: Нисходящий разбор]]

Предиктивный синтаксический анализ

2015-05-25T11:08:59Z

194.85.160.130: /* Нерекурсивный нисходящий парсер */

{{В разработке}}
Для [[LL(k)-грамматики, множества FIRST и FOLLOW | LL(1)-грамматик]] возможна автоматическая генерация парсеров, если известны множества FIRST и FOLLOW. Существуют общедоступные генераторы: ANTLR<ref>[http://www.antlr.org/ ANTLR {{---}} Parser generator]</ref>, Bison<ref>[http://www.gnu.org/software/bison/ Bison {{---}} GNU Project]</ref>, Yacc<ref>[http://dinosaur.compilertools.net/ Lex & Yacc {{---}} A Lexical Analyzer Generator and Yet Another Compiler-Compiler]</ref>, Happy<ref>[https://www.haskell.org/happy/ Happy {{---}} The Parser Generator for Haskell]</ref>.

== Общая схема построения рекурсивных парсеров с помощью FIRST и FOLLOW ==

Пусть <tex>\Gamma =\langle \Sigma, N, S, P \rangle</tex> {{---}} LL(1)-грамматика. Построим для нее парсер.

Для каждого нетерминала <tex>A : A \rightarrow \alpha_1 \mid \alpha_2 \mid \ldots \mid \alpha_k </tex> создадим функцию <tex> \mathtt{A}() : \mathtt{Node} </tex>, возвращающую фрагмент дерева разбора, выведенный из нетерминала <tex>A</tex>.

Здесь <tex>\mathtt{Node}</tex> {{---}} структура следующего вида:
'''struct''' Node
children : '''list<Node>'''
value : '''string''' // имя нетерминала или текст терминала
'''function''' addChild('''Node''') // функция, подвешивающая поддерево к данному узлу

Каждый момент времени парсер работает с определённым '''токеном''' (англ. ''token'') входного слово <tex>s</tex>. Токен {{---}} один или несколько нетерминалов, для удобства объединяемые по смыслу в одну логическую единицы. Примерами токенов могут выступать следующие лексические единицы:
* произвольный символ <tex> c </tex>,
* целое слово, например <tex> public </tex>,
* число со знаком, обозначаемое далее для краткости как <tex> n </tex>.
В общем случае, токеном может являться любое слово, удовлетворяющее произвольному [[Регулярные языки: два определения и их эквивалентность | регулярному выражению]].

[[Файл:string_token.png|300px]]

В псевдокоде используются следующие обозначения:
* <tex>\mathtt{curToken}</tex> {{---}} текущий токен строки,
* <tex>\mathtt{nextToken()}</tex> {{---}} функция, записывающая в <tex>\mathtt{curToken}</tex> следующий за ним токен.

Тогда шаблон функции рекурсивного парсера для нетерминала <tex>A</tex> имеет вид:

A() : '''Node'''
Node res = Node("A")
'''switch''' (curToken) : // принимаем решение в зависимости от текущего токена строки
'''case''' <tex>\mathrm{FIRST}(\alpha_1) \cup (\mathrm{FOLLOW}(A)\ \mathrm{if}\ \varepsilon \in \mathrm{FIRST}(\alpha_1))</tex> :
// <tex>\alpha_1 = X_1X_2 \ldots X_{t}</tex> 
'''for''' i = 1 .. t
'''if''' <tex> X_i </tex> {{---}} нетерминал
consume(<tex>X_i</tex>)
res.addChild(Node("<tex>X_i</tex>")
nextToken()
'''else''' // <tex>X_i</tex> {{---}} терминал, нужно вызвать соответствующую ему функцию рекурсивного парсера 
Node t = <tex>X_i()</tex>
res.addChild(t)
'''break'''
'''case''' <tex>\mathrm{FIRST}(\alpha_2) \cup (\mathrm{FOLLOW}(A)\ \mathrm{if}\ \varepsilon \in \mathrm{FIRST}(\alpha_2))</tex> :
...
'''break'''
...
'''default''' :
error("unexpected char")
'''return''' res

'''function''' consume(c: '''char''')
'''if''' curToken != c
error("expected " + c)
nextToken()

Такой парсер не только разбирает строку, но и находит ошибки в неудовлетворяющих грамматике выражениях.

== Пример ==
Рассмотрим построение парсера на примере LL(1)-грамматики арифметических выражений, которая уже была разобрана [[Построение FIRST и FOLLOW#Пример | ранее]]:

<tex>
E \to TE' \\
E' \to +TE' \mid \varepsilon \\
T \to FT' \\
T' \to * FT' \mid \varepsilon \\
F \to n \mid (E)
</tex>

Напомним, что множества <tex>\mathrm{FIRST}</tex> и <tex>\mathrm{FOLLOW}</tex> для неё выглядят так:

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Правило
!style="background-color:#EEE"| FIRST
!style="background-color:#EEE"| FOLLOW
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \varepsilon\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ ,\ )\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ *,\ \varepsilon\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ ,\ )\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ *, \ +,\ \$\ ,\ )\ \} </tex>
|}

=== Псевдокоды ===
Построим функции обработки некоторых нетерминалов, используя описанный выше шаблон:

E() : '''Node'''
Node res = Node("E")
'''switch''' (curToken)
'''case''' n, '(' :
res.addChild(T())
res.addChild(E'())
'''break'''
'''default''' :
error("unexpected char")
'''return''' res

E'() : '''Node'''
Node res = Node("E'")
'''switch''' (curToken)
'''case''' '+' :
consume('+')
res.addChild(Node("+"))
res.addChild(T())
res.addChild(E'())
'''break'''
'''case''' '$', ')' :
'''break'''
'''default''' :
error("unexpected char")
'''return''' res

F() : '''Node'''
Node res = Node("F")
'''switch''' (curToken)
'''case''' n :
consume(n)
res.addChild(Node(curToken)) // <tex>\mathtt{curToken}</tex> подпадает под шаблон <tex>n</tex>, поэтому запишем его в <tex>\mathtt{value}</tex> вершины
'''break'''
'''case''' '(' :
consume('(')
res.addChild(Node("("))
res.addChild(E())
consume(')')
res.addChild(Node(")"))
'''default''' :
error("unexpected char")
'''return''' res

Функции для <tex>T</tex> и <tex>T'</tex> строятся аналогично.

=== Дерево разбора ===

Рассмотрим дерево разбора для выражения <tex>(1 + 2) * 3</tex> и несколько первых шагов алгоритма рекурсивного разбора. Сначала вызывается функция стартового нетерминала грамматики, то есть <tex>E</tex>. Так как первым токеном является '(', то будет использовано первое правило разбора <tex>TE'</tex>. Поэтому к вершине с меткой <tex>E</tex> добавятся два ребёнка: <tex>T</tex> и <tex>E'</tex>. А рекурсивный разборщик перейдёт к нетерминалу <tex>T</tex>. По-прежнему curToken равен '(', поэтому в <tex>F</tex> сработает второй case, первым ребёнком добавится '(', curToken станет равен <tex>1</tex>, а разборщик перейдёт к нетерминалу <tex>E</tex>. После того как выражение после '(', которое выводится из <tex>E</tex>, будет полностью разобрано, функция рекурсивного разбора для <tex>F</tex> добавит ')' последним сыном к этому нетерминалу.

Продолжая в том же духе, мы построим всё дерево разбора данного выражения.

[[Файл:parse_ex1.png|400px|thumb|center|Дерево разбора выражения <tex>(1 + 2) * 3</tex>]]

== Нерекурсивный нисходящий парсер ==

[[Файл:Parse_table.png|400px|right]]

Рекурсивные разборщики можно генерировать автоматически, зная множества FIRST и FOLLOW, так как они имеют достаточно прозрачный шаблон построения. Альтернативным способом осуществления нисходящего синтаксического анализа является построение нерекурсивного нисходящего парсера. Его можно построить с помощью явного использования стека (вместо неявного при рекурсивных вызовах). Такое анализатор имитирует левое порождение.

Нерекурсивный предиктивный синтаксический анализатор содержит дополнительно стек, содержащий последовательность терминалов и нетерминалов, и таблицу синтаксического анализа. На стеке располагается последовательность символов грамматики с маркером конца строки $ на дне. В начале процесса анализа строки стек содержит стартовый нетерминал грамматики непосредственно над символом $. Таблица синтаксического анализа представляет собой двухмерный массив М[X, а], где X — нетерминал, а — терминал или символ $.

Нерекурсивный синтаксический анализатор смотрит на текущий токен строки a и на символ на вершине стека X, а затем принимает решение в зависимости от одного из возникающих ниже случаев:
* если Х=curToken=$, синтаксический анализатор прекращает работу, так как разбор строки завершён,
* eсли Х=curToken≠$, синтаксический анализатор снимает со стека X и перемещает указатель входного потока к следующему токену (то есть вызывает nextToken),
* eсли X представляет собой нетерминал, программа рассматривает запись M[Х,а] таблицы разбора М. Эта запись представляет собой либо X-продукцию грамматики, либо запись об ошибке. Если, например, М[Х,а] = {X → UVW}, синтаксический анализатор замещает X на вершине стека на WVU (с U на вершине стека). В кач-ве выхода синтаксический анализатор просто выводит использованную продукцию. Если M[Х,а] = error, синтаксический анализатор вызывает программу восстановления после ошибки.

=== Псевдокод ===
<code style = "display: inline-block;">
function nonRecursiveParser(w : String):
s : Stack
s.push(bottom)
s.push(Start)
do
X = s.top()
if X == c
c = nextToken()
s.pop()
else if X in Sigma
error("unexpected symbol")
else if M[X, c] == undefined // запись об ошибке
error("unexpected symbol")
else if M[X, c] == X -> Y_1 Y_2 ... Y_k
s.pop()
for i = k downto 1
s.push(Y_i)
while s.top() != bottom
</code>

=== Пример ===

<tex>
(1) \ E \to TE' \\
(2) \ E' \to +TE' \\
(3) \ E' \to \varepsilon \\
(4) \ T \to FT' \\
(5) \ T' \to \times FT' \\
(6) \ T' \to \varepsilon \\
(7) \ F \to n \\
(8) \ F \to (E)
</tex>

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"|
!style="background-color:#EEE"| n
!style="background-color:#EEE"| (
!style="background-color:#EEE"| )
!style="background-color:#EEE"| +
!style="background-color:#EEE"| *
!style="background-color:#EEE"| $
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>1 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"| <tex>3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>2 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"| <tex>3 </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>4 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"| <tex>6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>6 </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>8 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>\perp</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|}

[[Файл:Parse_stack.png|500px]]

== Примечания ==
<references/>
== Источники информации ==
* Альфред Ахо, Рави Сети, Джеффри Ульман. Компиляторы. Принципы, технологии, инструменты. Издательство Вильямс. Второе издание. 2008. Стр. 288 {{---}} 294.

[[Категория: Методы трансляции]]
[[Категория: Нисходящий разбор]]

Предиктивный синтаксический анализ

2015-05-25T11:03:04Z

194.85.160.130: /* Пример */

{{В разработке}}
Для [[LL(k)-грамматики, множества FIRST и FOLLOW | LL(1)-грамматик]] возможна автоматическая генерация парсеров, если известны множества FIRST и FOLLOW. Существуют общедоступные генераторы: ANTLR<ref>[http://www.antlr.org/ ANTLR {{---}} Parser generator]</ref>, Bison<ref>[http://www.gnu.org/software/bison/ Bison {{---}} GNU Project]</ref>, Yacc<ref>[http://dinosaur.compilertools.net/ Lex & Yacc {{---}} A Lexical Analyzer Generator and Yet Another Compiler-Compiler]</ref>, Happy<ref>[https://www.haskell.org/happy/ Happy {{---}} The Parser Generator for Haskell]</ref>.

== Общая схема построения рекурсивных парсеров с помощью FIRST и FOLLOW ==

Пусть <tex>\Gamma =\langle \Sigma, N, S, P \rangle</tex> {{---}} LL(1)-грамматика. Построим для нее парсер.

Для каждого нетерминала <tex>A : A \rightarrow \alpha_1 \mid \alpha_2 \mid \ldots \mid \alpha_k </tex> создадим функцию <tex> \mathtt{A}() : \mathtt{Node} </tex>, возвращающую фрагмент дерева разбора, выведенный из нетерминала <tex>A</tex>.

Здесь <tex>\mathtt{Node}</tex> {{---}} структура следующего вида:
'''struct''' Node
children : '''list<Node>'''
value : '''string''' // имя нетерминала или текст терминала
'''function''' addChild('''Node''') // функция, подвешивающая поддерево к данному узлу

Каждый момент времени парсер работает с определённым '''токеном''' (англ. ''token'') входного слово <tex>s</tex>. Токен {{---}} один или несколько нетерминалов, для удобства объединяемые по смыслу в одну логическую единицы. Примерами токенов могут выступать следующие лексические единицы:
* произвольный символ <tex> c </tex>,
* целое слово, например <tex> public </tex>,
* число со знаком, обозначаемое далее для краткости как <tex> n </tex>.
В общем случае, токеном может являться любое слово, удовлетворяющее произвольному [[Регулярные языки: два определения и их эквивалентность | регулярному выражению]].

[[Файл:string_token.png|300px]]

В псевдокоде используются следующие обозначения:
* <tex>\mathtt{curToken}</tex> {{---}} текущий токен строки,
* <tex>\mathtt{nextToken()}</tex> {{---}} функция, записывающая в <tex>\mathtt{curToken}</tex> следующий за ним токен.

Тогда шаблон функции рекурсивного парсера для нетерминала <tex>A</tex> имеет вид:

A() : '''Node'''
Node res = Node("A")
'''switch''' (curToken) : // принимаем решение в зависимости от текущего токена строки
'''case''' <tex>\mathrm{FIRST}(\alpha_1) \cup (\mathrm{FOLLOW}(A)\ \mathrm{if}\ \varepsilon \in \mathrm{FIRST}(\alpha_1))</tex> :
// <tex>\alpha_1 = X_1X_2 \ldots X_{t}</tex> 
'''for''' i = 1 .. t
'''if''' <tex> X_i </tex> {{---}} нетерминал
consume(<tex>X_i</tex>)
res.addChild(Node("<tex>X_i</tex>")
nextToken()
'''else''' // <tex>X_i</tex> {{---}} терминал, нужно вызвать соответствующую ему функцию рекурсивного парсера 
Node t = <tex>X_i()</tex>
res.addChild(t)
'''break'''
'''case''' <tex>\mathrm{FIRST}(\alpha_2) \cup (\mathrm{FOLLOW}(A)\ \mathrm{if}\ \varepsilon \in \mathrm{FIRST}(\alpha_2))</tex> :
...
'''break'''
...
'''default''' :
error("unexpected char")
'''return''' res

'''function''' consume(c: '''char''')
'''if''' curToken != c
error("expected " + c)
nextToken()

Такой парсер не только разбирает строку, но и находит ошибки в неудовлетворяющих грамматике выражениях.

== Пример ==
Рассмотрим построение парсера на примере LL(1)-грамматики арифметических выражений, которая уже была разобрана [[Построение FIRST и FOLLOW#Пример | ранее]]:

<tex>
E \to TE' \\
E' \to +TE' \mid \varepsilon \\
T \to FT' \\
T' \to * FT' \mid \varepsilon \\
F \to n \mid (E)
</tex>

Напомним, что множества <tex>\mathrm{FIRST}</tex> и <tex>\mathrm{FOLLOW}</tex> для неё выглядят так:

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Правило
!style="background-color:#EEE"| FIRST
!style="background-color:#EEE"| FOLLOW
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \varepsilon\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ ,\ )\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ *,\ \varepsilon\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ ,\ )\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ *, \ +,\ \$\ ,\ )\ \} </tex>
|}

=== Псевдокоды ===
Построим функции обработки некоторых нетерминалов, используя описанный выше шаблон:

E() : '''Node'''
Node res = Node("E")
'''switch''' (curToken)
'''case''' n, '(' :
res.addChild(T())
res.addChild(E'())
'''break'''
'''default''' :
error("unexpected char")
'''return''' res

E'() : '''Node'''
Node res = Node("E'")
'''switch''' (curToken)
'''case''' '+' :
consume('+')
res.addChild(Node("+"))
res.addChild(T())
res.addChild(E'())
'''break'''
'''case''' '$', ')' :
'''break'''
'''default''' :
error("unexpected char")
'''return''' res

F() : '''Node'''
Node res = Node("F")
'''switch''' (curToken)
'''case''' n :
consume(n)
res.addChild(Node(curToken)) // <tex>\mathtt{curToken}</tex> подпадает под шаблон <tex>n</tex>, поэтому запишем его в <tex>\mathtt{value}</tex> вершины
'''break'''
'''case''' '(' :
consume('(')
res.addChild(Node("("))
res.addChild(E())
consume(')')
res.addChild(Node(")"))
'''default''' :
error("unexpected char")
'''return''' res

Функции для <tex>T</tex> и <tex>T'</tex> строятся аналогично.

=== Дерево разбора ===

Рассмотрим дерево разбора для выражения <tex>(1 + 2) * 3</tex> и несколько первых шагов алгоритма рекурсивного разбора. Сначала вызывается функция стартового нетерминала грамматики, то есть <tex>E</tex>. Так как первым токеном является '(', то будет использовано первое правило разбора <tex>TE'</tex>. Поэтому к вершине с меткой <tex>E</tex> добавятся два ребёнка: <tex>T</tex> и <tex>E'</tex>. А рекурсивный разборщик перейдёт к нетерминалу <tex>T</tex>. По-прежнему curToken равен '(', поэтому в <tex>F</tex> сработает второй case, первым ребёнком добавится '(', curToken станет равен <tex>1</tex>, а разборщик перейдёт к нетерминалу <tex>E</tex>. После того как выражение после '(', которое выводится из <tex>E</tex>, будет полностью разобрано, функция рекурсивного разбора для <tex>F</tex> добавит ')' последним сыном к этому нетерминалу.

Продолжая в том же духе, мы построим всё дерево разбора данного выражения.

[[Файл:parse_ex1.png|400px|thumb|center|Дерево разбора выражения <tex>(1 + 2) * 3</tex>]]

== Нерекурсивный нисходящий парсер ==

[[Файл:Parse_table.png|350px|right]]

Рекурсивные разборщики можно генерировать автоматически, зная множества FIRST и FOLLOW, так как они имеют достаточно прозрачный шаблон построения. Альтернативным способом осуществления нисходящего синтаксического анализа является построение нерекурсивного нисходящего парсера. Его можно построить с помощью явного использования стека (вместо неявного при рекурсивных вызовах). Такое анализатор имитирует левое порождение.

Нерекурсивный предиктивный синтаксический анализатор содержит дополнительно стек, содержащий последовательность терминалов и нетерминалов, и таблицу синтаксического анализа. На стеке располагается последовательность символов грамматики с маркером конца строки $ на дне. В начале процесса анализа строки стек содержит стартовый нетерминал грамматики непосредственно над символом $. Таблица синтаксического анализа представляет собой двухмерный массив М[X, а], где X — нетерминал, а — терминал или символ $.

Нерекурсивный синтаксический анализатор смотрит на текущий токен строки a и на символ на вершине стека X, а затем принимает решение в зависимости от одного из возникающих ниже случаев:
* если Х=curToken=$, синтаксический анализатор прекращает работу, так как разбор строки завершён,
* eсли Х=curToken≠$, синтаксический анализатор снимает со стека X и перемещает указатель входного потока к следующему токену (то есть вызывает nextToken),
* eсли X представляет собой нетерминал, программа рассматривает запись M[Х,а] таблицы разбора М. Эта запись представляет собой либо X-продукцию грамматики, либо запись об ошибке. Если, например, М[Х,а] = {X → UVW}, синтаксический анализатор замещает X на вершине стека на WVU (с U на вершине стека). В кач-ве выхода синтаксический анализатор просто выводит использованную продукцию. Если M[Х,а] = error, синтаксический анализатор вызывает программу восстановления после ошибки.

=== Псевдокод ===

<code>
function nonRecursiveParser(w : String):
s : Stack
s.push(bottom)
s.push(Start)
do
X = s.top()
if X == c
c = nextToken()
s.pop()
else if X in Sigma
error("unexpected symbol")
else if M[X, c] == undefined // запись об ошибке
error("unexpected symbol")
else if M[X, c] == X -> Y_1 Y_2 ... Y_k
s.pop()
for i = k downto 1
s.push(Y_i)
while s.top() != bottom
</code>

=== Пример ===

<tex>
(1) \ E \to TE' \\
(2) \ E' \to +TE' \\
(3) \ E' \to \varepsilon \\
(4) \ T \to FT' \\
(5) \ T' \to \times FT' \\
(6) \ T' \to \varepsilon \\
(7) \ F \to n \\
(8) \ F \to (E)
</tex>

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"|
!style="background-color:#EEE"| n
!style="background-color:#EEE"| (
!style="background-color:#EEE"| )
!style="background-color:#EEE"| +
!style="background-color:#EEE"| *
!style="background-color:#EEE"| $
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>1 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"| <tex>3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>2 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"| <tex>3 </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>4 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"| <tex>6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>6 </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>8 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>\perp</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|}

[[Файл:Parse_stack.png|500px]]

== Примечания ==
<references/>
== Источники информации ==
* Альфред Ахо, Рави Сети, Джеффри Ульман. Компиляторы. Принципы, технологии, инструменты. Издательство Вильямс. Второе издание. 2008. Стр. 288 {{---}} 294.

[[Категория: Методы трансляции]]
[[Категория: Нисходящий разбор]]

Предиктивный синтаксический анализ

2015-05-25T10:55:47Z

194.85.160.130: /* Общая схема построения рекурсивных парсеров с помощью FIRST и FOLLOW */

{{В разработке}}
Для [[LL(k)-грамматики, множества FIRST и FOLLOW | LL(1)-грамматик]] возможна автоматическая генерация парсеров, если известны множества FIRST и FOLLOW. Существуют общедоступные генераторы: ANTLR<ref>[http://www.antlr.org/ ANTLR {{---}} Parser generator]</ref>, Bison<ref>[http://www.gnu.org/software/bison/ Bison {{---}} GNU Project]</ref>, Yacc<ref>[http://dinosaur.compilertools.net/ Lex & Yacc {{---}} A Lexical Analyzer Generator and Yet Another Compiler-Compiler]</ref>, Happy<ref>[https://www.haskell.org/happy/ Happy {{---}} The Parser Generator for Haskell]</ref>.

== Общая схема построения рекурсивных парсеров с помощью FIRST и FOLLOW ==

Пусть <tex>\Gamma =\langle \Sigma, N, S, P \rangle</tex> {{---}} LL(1)-грамматика. Построим для нее парсер.

Для каждого нетерминала <tex>A : A \rightarrow \alpha_1 \mid \alpha_2 \mid \ldots \mid \alpha_k </tex> создадим функцию <tex> \mathtt{A}() : \mathtt{Node} </tex>, возвращающую фрагмент дерева разбора, выведенный из нетерминала <tex>A</tex>.

Здесь <tex>\mathtt{Node}</tex> {{---}} структура следующего вида:
'''struct''' Node
children : '''list<Node>'''
value : '''string''' // имя нетерминала или текст терминала
'''function''' addChild('''Node''') // функция, подвешивающая поддерево к данному узлу

Каждый момент времени парсер работает с определённым '''токеном''' (англ. ''token'') входного слово <tex>s</tex>. Токен {{---}} один или несколько нетерминалов, для удобства объединяемые по смыслу в одну логическую единицы. Примерами токенов могут выступать следующие лексические единицы:
* произвольный символ <tex> c </tex>,
* целое слово, например <tex> public </tex>,
* число со знаком, обозначаемое далее для краткости как <tex> n </tex>.
В общем случае, токеном может являться любое слово, удовлетворяющее произвольному [[Регулярные языки: два определения и их эквивалентность | регулярному выражению]].

[[Файл:string_token.png|300px]]

В псевдокоде используются следующие обозначения:
* <tex>\mathtt{curToken}</tex> {{---}} текущий токен строки,
* <tex>\mathtt{nextToken()}</tex> {{---}} функция, записывающая в <tex>\mathtt{curToken}</tex> следующий за ним токен.

Тогда шаблон функции рекурсивного парсера для нетерминала <tex>A</tex> имеет вид:

A() : '''Node'''
Node res = Node("A")
'''switch''' (curToken) : // принимаем решение в зависимости от текущего токена строки
'''case''' <tex>\mathrm{FIRST}(\alpha_1) \cup (\mathrm{FOLLOW}(A)\ \mathrm{if}\ \varepsilon \in \mathrm{FIRST}(\alpha_1))</tex> :
// <tex>\alpha_1 = X_1X_2 \ldots X_{t}</tex> 
'''for''' i = 1 .. t
'''if''' <tex> X_i </tex> {{---}} нетерминал
consume(<tex>X_i</tex>)
res.addChild(Node("<tex>X_i</tex>")
nextToken()
'''else''' // <tex>X_i</tex> {{---}} терминал, нужно вызвать соответствующую ему функцию рекурсивного парсера 
Node t = <tex>X_i()</tex>
res.addChild(t)
'''break'''
'''case''' <tex>\mathrm{FIRST}(\alpha_2) \cup (\mathrm{FOLLOW}(A)\ \mathrm{if}\ \varepsilon \in \mathrm{FIRST}(\alpha_2))</tex> :
...
'''break'''
...
'''default''' :
error("unexpected char")
'''return''' res

'''function''' consume(c: '''char''')
'''if''' curToken != c
error("expected " + c)
nextToken()

Такой парсер не только разбирает строку, но и находит ошибки в неудовлетворяющих грамматике выражениях.

== Пример ==
Рассмотрим построение парсера на примере LL(1)-грамматики арифметических выражений, которая уже была разобрана [[Построение FIRST и FOLLOW#Пример | ранее]]:

<tex>
E \to TE' \\
E' \to +TE' \mid \varepsilon \\
T \to FT' \\
T' \to \times FT' \mid \varepsilon \\
F \to n \mid (E)
</tex>

Напомним, что множества <tex>\mathrm{FIRST}</tex> и <tex>\mathrm{FOLLOW}</tex> для неё выглядят так:

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Правило
!style="background-color:#EEE"| FIRST
!style="background-color:#EEE"| FOLLOW
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \varepsilon\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ ,\ )\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \times,\ \varepsilon\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ ,\ )\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \times, \ +,\ \$\ ,\ )\ \} </tex>
|}

=== Псевдокоды ===
Построим функции обработки некоторых нетерминалов, используя описанный выше шаблон:

E() : '''Node'''
Node res = Node("E")
'''switch''' (curToken)
'''case''' <tex> n,\ ( </tex> :
res.addChild(T())
res.addChild(E'())
'''break'''
'''default''' :
error("unexpected char")
'''return''' res

E'()
res = Node("E'")
switch(curToken)
case '+' :
consume('+')
res.addChild(Node("+"))
res.addChild(T())
res.addChild(E'())
break
case '$', ')' :
break
default :
error("unexpected char")
return res

F()
res = Node("F")
switch(curToken)
case 'n' :
consume('n')
res.addChild(Node("n"))
break
case '(' :
consume('(')
res.addChild(Node("("))
res.addChild(E())
consume(')')
res.addChild(Node(")"))
default :
error("unexpected char")
return res

Функции для <tex>T</tex> и <tex>T'</tex> строятся аналогично.

=== Дерево разбора ===

Рассмотрим дерево разбора для выражения (1 + 2) * 3 и несколько первых шагов алгоритма рекурсивного разбора. Сначала вызывается функция стартового нетерминала грамматики, то есть <tex>E</tex>. Так как первым токеном является '(', то будет использовано первое правило разбора <tex>TE'</tex>. Поэтому к вершине с меткой <tex>E</tex> добавятся два ребёнка: <tex>T</tex> и <tex>E'</tex>. А рекурсивный разборщик перейдёт к нетерминалу <tex>T</tex>. По-прежнему curToken равен '(', поэтому в <tex>F</tex> сработает второй case, первым ребёнком добавится '(', curToken станет равен <tex>1</tex>, а разборщик перейдёт к нетерминалу <tex>E</tex>. После того как выражение после '(', которое выводится из <tex>E</tex>, будет полностью разобрано, функция рекурсивного разбора для <tex>F</tex> добавит ')' последним сыном к этому нетерминалу.

Продолжая в том же духе, мы построим всё дерево разбора данного выражения.

[[Файл:parse_ex1.png|400px|thumb|center|Дерево разбора выражения (1 + 2) * 3]]

== Нерекурсивный нисходящий парсер ==

[[Файл:Parse_table.png|350px|right]]

Рекурсивные разборщики можно генерировать автоматически, зная множества FIRST и FOLLOW, так как они имеют достаточно прозрачный шаблон построения. Альтернативным способом осуществления нисходящего синтаксического анализа является построение нерекурсивного нисходящего парсера. Его можно построить с помощью явного использования стека (вместо неявного при рекурсивных вызовах). Такое анализатор имитирует левое порождение.

Нерекурсивный предиктивный синтаксический анализатор содержит дополнительно стек, содержащий последовательность терминалов и нетерминалов, и таблицу синтаксического анализа. На стеке располагается последовательность символов грамматики с маркером конца строки $ на дне. В начале процесса анализа строки стек содержит стартовый нетерминал грамматики непосредственно над символом $. Таблица синтаксического анализа представляет собой двухмерный массив М[X, а], где X — нетерминал, а — терминал или символ $.

Нерекурсивный синтаксический анализатор смотрит на текущий токен строки a и на символ на вершине стека X, а затем принимает решение в зависимости от одного из возникающих ниже случаев:
* если Х=curToken=$, синтаксический анализатор прекращает работу, так как разбор строки завершён,
* eсли Х=curToken≠$, синтаксический анализатор снимает со стека X и перемещает указатель входного потока к следующему токену (то есть вызывает nextToken),
* eсли X представляет собой нетерминал, программа рассматривает запись M[Х,а] таблицы разбора М. Эта запись представляет собой либо X-продукцию грамматики, либо запись об ошибке. Если, например, М[Х,а] = {X → UVW}, синтаксический анализатор замещает X на вершине стека на WVU (с U на вершине стека). В кач-ве выхода синтаксический анализатор просто выводит использованную продукцию. Если M[Х,а] = error, синтаксический анализатор вызывает программу восстановления после ошибки.

=== Псевдокод ===

<code>
function nonRecursiveParser(w : String):
s : Stack
s.push(bottom)
s.push(Start)
do
X = s.top()
if X == c
c = nextToken()
s.pop()
else if X in Sigma
error("unexpected symbol")
else if M[X, c] == undefined // запись об ошибке
error("unexpected symbol")
else if M[X, c] == X -> Y_1 Y_2 ... Y_k
s.pop()
for i = k downto 1
s.push(Y_i)
while s.top() != bottom
</code>

=== Пример ===

<tex>
(1) \ E \to TE' \\
(2) \ E' \to +TE' \\
(3) \ E' \to \varepsilon \\
(4) \ T \to FT' \\
(5) \ T' \to \times FT' \\
(6) \ T' \to \varepsilon \\
(7) \ F \to n \\
(8) \ F \to (E)
</tex>

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"|
!style="background-color:#EEE"| n
!style="background-color:#EEE"| (
!style="background-color:#EEE"| )
!style="background-color:#EEE"| +
!style="background-color:#EEE"| *
!style="background-color:#EEE"| $
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>1 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"| <tex>3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>2 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"| <tex>3 </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>4 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"| <tex>6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>6 </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>8 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>\perp</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|}

[[Файл:Parse_stack.png|500px]]

== Примечания ==
<references/>
== Источники информации ==
* Альфред Ахо, Рави Сети, Джеффри Ульман. Компиляторы. Принципы, технологии, инструменты. Издательство Вильямс. Второе издание. 2008. Стр. 288 {{---}} 294.

[[Категория: Методы трансляции]]
[[Категория: Нисходящий разбор]]

Предиктивный синтаксический анализ

2015-05-25T10:55:02Z

194.85.160.130: /* Пример */

{{В разработке}}
Для [[LL(k)-грамматики, множества FIRST и FOLLOW | LL(1)-грамматик]] возможна автоматическая генерация парсеров, если известны множества FIRST и FOLLOW. Существуют общедоступные генераторы: ANTLR<ref>[http://www.antlr.org/ ANTLR {{---}} Parser generator]</ref>, Bison<ref>[http://www.gnu.org/software/bison/ Bison {{---}} GNU Project]</ref>, Yacc<ref>[http://dinosaur.compilertools.net/ Lex & Yacc {{---}} A Lexical Analyzer Generator and Yet Another Compiler-Compiler]</ref>, Happy<ref>[https://www.haskell.org/happy/ Happy {{---}} The Parser Generator for Haskell]</ref>.

== Общая схема построения рекурсивных парсеров с помощью FIRST и FOLLOW ==

Пусть <tex>\Gamma =\langle \Sigma, N, S, P \rangle</tex> {{---}} LL(1)-грамматика. Построим для нее парсер.

Для каждого нетерминала <tex>A : A \rightarrow \alpha_1 \mid \alpha_2 \mid \ldots \mid \alpha_k </tex> создадим функцию <tex> \mathtt{A}() : \mathtt{Node} </tex>, возвращающую фрагмент дерева разбора, выведенный из нетерминала <tex>A</tex>.

Здесь <tex>\mathtt{Node}</tex> {{---}} структура следующего вида:
'''struct''' Node
children : '''list<Node>'''
value : '''string''' // имя нетерминала или текст терминала
'''function''' addChild('''Node''') // функция, подвешивающая поддерево к данному узлу

Каждый момент времени парсер работает с определённым '''токеном''' (англ. ''token'') входного слово <tex>s</tex>. Токен {{---}} один или несколько нетерминалов, для удобства объединяемые по смыслу в одну логическую единицы. Примерами токенов могут выступать следующие лексические единицы:
* произвольный символ <tex> c </tex>,
* целое слово, например <tex> public </tex>,
* число со знаком, обозначаемое далее для краткости как <tex> n </tex>,
В общем случае, токеном может являться любое слово, удовлетворяющее произвольному [[Регулярные языки: два определения и их эквивалентность | регулярному выражению]].

[[Файл:string_token.png|300px]]

В псевдокоде используются следующие обозначения:
* <tex>\mathtt{curToken}</tex> {{---}} текущий токен строки,
* <tex>\mathtt{nextToken()}</tex> {{---}} функция, записывающая в <tex>\mathtt{curToken}</tex> следующий за ним токен.

Тогда шаблон функции рекурсивного парсера для нетерминала <tex>A</tex> имеет вид:

A() : '''Node'''
Node res = Node("A")
'''switch''' (curToken) : // принимаем решение в зависимости от текущего токена строки
'''case''' <tex>\mathrm{FIRST}(\alpha_1) \cup (\mathrm{FOLLOW}(A)\ \mathrm{if}\ \varepsilon \in \mathrm{FIRST}(\alpha_1))</tex> :
// <tex>\alpha_1 = X_1X_2 \ldots X_{t}</tex> 
'''for''' i = 1 .. t
'''if''' <tex> X_i </tex> {{---}} нетерминал
consume(<tex>X_i</tex>)
res.addChild(Node("<tex>X_i</tex>")
nextToken()
'''else''' // <tex>X_i</tex> {{---}} терминал, нужно вызвать соответствующую ему функцию рекурсивного парсера 
Node t = <tex>X_i()</tex>
res.addChild(t)
'''break'''
'''case''' <tex>\mathrm{FIRST}(\alpha_2) \cup (\mathrm{FOLLOW}(A)\ \mathrm{if}\ \varepsilon \in \mathrm{FIRST}(\alpha_2))</tex> :
...
'''break'''
...
'''default''' :
error("unexpected char")
'''return''' res

'''function''' consume(c: '''char''')
'''if''' curToken != c
error("expected " + c)
nextToken()

Такой парсер не только разбирает строку, но и находит ошибки в неудовлетворяющих грамматике выражениях.

== Пример ==
Рассмотрим построение парсера на примере LL(1)-грамматики арифметических выражений, которая уже была разобрана [[Построение FIRST и FOLLOW#Пример | ранее]]:

<tex>
E \to TE' \\
E' \to +TE' \mid \varepsilon \\
T \to FT' \\
T' \to \times FT' \mid \varepsilon \\
F \to n \mid (E)
</tex>

Напомним, что множества <tex>\mathrm{FIRST}</tex> и <tex>\mathrm{FOLLOW}</tex> для неё выглядят так:

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Правило
!style="background-color:#EEE"| FIRST
!style="background-color:#EEE"| FOLLOW
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \varepsilon\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ ,\ )\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \times,\ \varepsilon\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ ,\ )\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \times, \ +,\ \$\ ,\ )\ \} </tex>
|}

=== Псевдокоды ===
Построим функции обработки некоторых нетерминалов, используя описанный выше шаблон:

E() : '''Node'''
Node res = Node("E")
'''switch''' (curToken)
'''case''' <tex> n,\ ( </tex> :
res.addChild(T())
res.addChild(E'())
'''break'''
'''default''' :
error("unexpected char")
'''return''' res

E'()
res = Node("E'")
switch(curToken)
case '+' :
consume('+')
res.addChild(Node("+"))
res.addChild(T())
res.addChild(E'())
break
case '$', ')' :
break
default :
error("unexpected char")
return res

F()
res = Node("F")
switch(curToken)
case 'n' :
consume('n')
res.addChild(Node("n"))
break
case '(' :
consume('(')
res.addChild(Node("("))
res.addChild(E())
consume(')')
res.addChild(Node(")"))
default :
error("unexpected char")
return res

Функции для <tex>T</tex> и <tex>T'</tex> строятся аналогично.

=== Дерево разбора ===

Рассмотрим дерево разбора для выражения (1 + 2) * 3 и несколько первых шагов алгоритма рекурсивного разбора. Сначала вызывается функция стартового нетерминала грамматики, то есть <tex>E</tex>. Так как первым токеном является '(', то будет использовано первое правило разбора <tex>TE'</tex>. Поэтому к вершине с меткой <tex>E</tex> добавятся два ребёнка: <tex>T</tex> и <tex>E'</tex>. А рекурсивный разборщик перейдёт к нетерминалу <tex>T</tex>. По-прежнему curToken равен '(', поэтому в <tex>F</tex> сработает второй case, первым ребёнком добавится '(', curToken станет равен <tex>1</tex>, а разборщик перейдёт к нетерминалу <tex>E</tex>. После того как выражение после '(', которое выводится из <tex>E</tex>, будет полностью разобрано, функция рекурсивного разбора для <tex>F</tex> добавит ')' последним сыном к этому нетерминалу.

Продолжая в том же духе, мы построим всё дерево разбора данного выражения.

[[Файл:parse_ex1.png|400px|thumb|center|Дерево разбора выражения (1 + 2) * 3]]

== Нерекурсивный нисходящий парсер ==

[[Файл:Parse_table.png|350px|right]]

Рекурсивные разборщики можно генерировать автоматически, зная множества FIRST и FOLLOW, так как они имеют достаточно прозрачный шаблон построения. Альтернативным способом осуществления нисходящего синтаксического анализа является построение нерекурсивного нисходящего парсера. Его можно построить с помощью явного использования стека (вместо неявного при рекурсивных вызовах). Такое анализатор имитирует левое порождение.

Нерекурсивный предиктивный синтаксический анализатор содержит дополнительно стек, содержащий последовательность терминалов и нетерминалов, и таблицу синтаксического анализа. На стеке располагается последовательность символов грамматики с маркером конца строки $ на дне. В начале процесса анализа строки стек содержит стартовый нетерминал грамматики непосредственно над символом $. Таблица синтаксического анализа представляет собой двухмерный массив М[X, а], где X — нетерминал, а — терминал или символ $.

Нерекурсивный синтаксический анализатор смотрит на текущий токен строки a и на символ на вершине стека X, а затем принимает решение в зависимости от одного из возникающих ниже случаев:
* если Х=curToken=$, синтаксический анализатор прекращает работу, так как разбор строки завершён,
* eсли Х=curToken≠$, синтаксический анализатор снимает со стека X и перемещает указатель входного потока к следующему токену (то есть вызывает nextToken),
* eсли X представляет собой нетерминал, программа рассматривает запись M[Х,а] таблицы разбора М. Эта запись представляет собой либо X-продукцию грамматики, либо запись об ошибке. Если, например, М[Х,а] = {X → UVW}, синтаксический анализатор замещает X на вершине стека на WVU (с U на вершине стека). В кач-ве выхода синтаксический анализатор просто выводит использованную продукцию. Если M[Х,а] = error, синтаксический анализатор вызывает программу восстановления после ошибки.

=== Псевдокод ===

<code>
function nonRecursiveParser(w : String):
s : Stack
s.push(bottom)
s.push(Start)
do
X = s.top()
if X == c
c = nextToken()
s.pop()
else if X in Sigma
error("unexpected symbol")
else if M[X, c] == undefined // запись об ошибке
error("unexpected symbol")
else if M[X, c] == X -> Y_1 Y_2 ... Y_k
s.pop()
for i = k downto 1
s.push(Y_i)
while s.top() != bottom
</code>

=== Пример ===

<tex>
(1) \ E \to TE' \\
(2) \ E' \to +TE' \\
(3) \ E' \to \varepsilon \\
(4) \ T \to FT' \\
(5) \ T' \to \times FT' \\
(6) \ T' \to \varepsilon \\
(7) \ F \to n \\
(8) \ F \to (E)
</tex>

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"|
!style="background-color:#EEE"| n
!style="background-color:#EEE"| (
!style="background-color:#EEE"| )
!style="background-color:#EEE"| +
!style="background-color:#EEE"| *
!style="background-color:#EEE"| $
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>1 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"| <tex>3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>2 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"| <tex>3 </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>4 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"| <tex>6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>6 </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>8 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>\perp</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|}

[[Файл:Parse_stack.png|500px]]

== Примечания ==
<references/>
== Источники информации ==
* Альфред Ахо, Рави Сети, Джеффри Ульман. Компиляторы. Принципы, технологии, инструменты. Издательство Вильямс. Второе издание. 2008. Стр. 288 {{---}} 294.

[[Категория: Методы трансляции]]
[[Категория: Нисходящий разбор]]

Предиктивный синтаксический анализ

2015-05-25T10:50:42Z

194.85.160.130:

{{В разработке}}
Для [[LL(k)-грамматики, множества FIRST и FOLLOW | LL(1)-грамматик]] возможна автоматическая генерация парсеров, если известны множества FIRST и FOLLOW. Существуют общедоступные генераторы: ANTLR<ref>[http://www.antlr.org/ ANTLR {{---}} Parser generator]</ref>, Bison<ref>[http://www.gnu.org/software/bison/ Bison {{---}} GNU Project]</ref>, Yacc<ref>[http://dinosaur.compilertools.net/ Lex & Yacc {{---}} A Lexical Analyzer Generator and Yet Another Compiler-Compiler]</ref>, Happy<ref>[https://www.haskell.org/happy/ Happy {{---}} The Parser Generator for Haskell]</ref>.

== Общая схема построения рекурсивных парсеров с помощью FIRST и FOLLOW ==

Пусть <tex>\Gamma =\langle \Sigma, N, S, P \rangle</tex> {{---}} LL(1)-грамматика. Построим для нее парсер.

Для каждого нетерминала <tex>A : A \rightarrow \alpha_1 \mid \alpha_2 \mid \ldots \mid \alpha_k </tex> создадим функцию <tex> \mathtt{A}() : \mathtt{Node} </tex>, возвращающую фрагмент дерева разбора, выведенный из нетерминала <tex>A</tex>.

Здесь <tex>\mathtt{Node}</tex> {{---}} структура следующего вида:
'''struct''' Node
children : '''list<Node>'''
value : '''string''' // имя нетерминала или текст терминала
'''function''' addChild('''Node''') // функция, подвешивающая поддерево к данному узлу

Каждый момент времени парсер работает с определённым '''токеном''' (англ. ''token'') входного слово <tex>s</tex>. Токен {{---}} один или несколько нетерминалов, для удобства объединяемые по смыслу в одну логическую единицы. Примерами токенов могут выступать следующие лексические единицы:
* произвольный символ <tex> c </tex>,
* целое слово, например <tex> public </tex>,
* число со знаком, обозначаемое далее для краткости как <tex> n </tex>,
В общем случае, токеном может являться любое слово, удовлетворяющее произвольному [[Регулярные языки: два определения и их эквивалентность | регулярному выражению]].

[[Файл:string_token.png|300px]]

В псевдокоде используются следующие обозначения:
* <tex>\mathtt{curToken}</tex> {{---}} текущий токен строки,
* <tex>\mathtt{nextToken()}</tex> {{---}} функция, записывающая в <tex>\mathtt{curToken}</tex> следующий за ним токен.

Тогда шаблон функции рекурсивного парсера для нетерминала <tex>A</tex> имеет вид:

A() : '''Node'''
Node res = Node("A")
'''switch''' (curToken) : // принимаем решение в зависимости от текущего токена строки
'''case''' <tex>\mathrm{FIRST}(\alpha_1) \cup (\mathrm{FOLLOW}(A)\ \mathrm{if}\ \varepsilon \in \mathrm{FIRST}(\alpha_1))</tex> :
// <tex>\alpha_1 = X_1X_2 \ldots X_{t}</tex> 
'''for''' i = 1 .. t
'''if''' <tex> X_i </tex> {{---}} нетерминал
consume(<tex>X_i</tex>)
res.addChild(Node("<tex>X_i</tex>")
nextToken()
'''else''' // <tex>X_i</tex> {{---}} терминал, нужно вызвать соответствующую ему функцию рекурсивного парсера 
Node t = <tex>X_i()</tex>
res.addChild(t)
'''break'''
'''case''' <tex>\mathrm{FIRST}(\alpha_2) \cup (\mathrm{FOLLOW}(A)\ \mathrm{if}\ \varepsilon \in \mathrm{FIRST}(\alpha_2))</tex> :
...
'''break'''
...
'''default''' :
error("unexpected char")
'''return''' res

'''function''' consume(c: '''char''')
'''if''' curToken != c
error("expected " + c)
nextToken()

Такой парсер не только разбирает строку, но и находит ошибки в неудовлетворяющих грамматике выражениях.

== Пример ==
Рассмотрим построение парсера на примере LL(1)-грамматики арифметических выражений.

<tex>
E \to TE' \\
E' \to +TE' \mid \varepsilon \\
T \to FT' \\
T' \to \times FT' \mid \varepsilon \\
F \to n \mid (E)
</tex>

Построим для нее множества <tex>FIRST</tex> и <tex>FOLLOW</tex> (их построение подробно разобрано [[Построение FIRST и FOLLOW#Пример | здесь]]).

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Правило
!style="background-color:#EEE"| FIRST
!style="background-color:#EEE"| FOLLOW
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \varepsilon\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ ,\ )\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \times,\ \varepsilon\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ ,\ )\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \times, \ +,\ \$\ ,\ )\ \} </tex>
|}

=== Псевдокоды ===
Построим функции обработки некоторых нетерминалов.

E()
res = Node("E")
switch(curToken)
case 'n', '(' :
res.addChild(T())
res.addChild(E'())
break
default :
error("unexpected char")
return res

E'()
res = Node("E'")
switch(curToken)
case '+' :
consume('+')
res.addChild(Node("+"))
res.addChild(T())
res.addChild(E'())
break
case '$', ')' :
break
default :
error("unexpected char")
return res

F()
res = Node("F")
switch(curToken)
case 'n' :
consume('n')
res.addChild(Node("n"))
break
case '(' :
consume('(')
res.addChild(Node("("))
res.addChild(E())
consume(')')
res.addChild(Node(")"))
default :
error("unexpected char")
return res

Функции для <tex>T</tex> и <tex>T'</tex> строятся аналогично.

=== Дерево разбора ===

Рассмотрим дерево разбора для выражения (1 + 2) * 3 и несколько первых шагов алгоритма рекурсивного разбора. Сначала вызывается функция стартового нетерминала грамматики, то есть <tex>E</tex>. Так как первым токеном является '(', то будет использовано первое правило разбора <tex>TE'</tex>. Поэтому к вершине с меткой <tex>E</tex> добавятся два ребёнка: <tex>T</tex> и <tex>E'</tex>. А рекурсивный разборщик перейдёт к нетерминалу <tex>T</tex>. По-прежнему curToken равен '(', поэтому в <tex>F</tex> сработает второй case, первым ребёнком добавится '(', curToken станет равен <tex>1</tex>, а разборщик перейдёт к нетерминалу <tex>E</tex>. После того как выражение после '(', которое выводится из <tex>E</tex>, будет полностью разобрано, функция рекурсивного разбора для <tex>F</tex> добавит ')' последним сыном к этому нетерминалу.

Продолжая в том же духе, мы построим всё дерево разбора данного выражения.

[[Файл:parse_ex1.png|400px|thumb|center|Дерево разбора выражения (1 + 2) * 3]]

== Нерекурсивный нисходящий парсер ==

[[Файл:Parse_table.png|350px|right]]

Рекурсивные разборщики можно генерировать автоматически, зная множества FIRST и FOLLOW, так как они имеют достаточно прозрачный шаблон построения. Альтернативным способом осуществления нисходящего синтаксического анализа является построение нерекурсивного нисходящего парсера. Его можно построить с помощью явного использования стека (вместо неявного при рекурсивных вызовах). Такое анализатор имитирует левое порождение.

Нерекурсивный предиктивный синтаксический анализатор содержит дополнительно стек, содержащий последовательность терминалов и нетерминалов, и таблицу синтаксического анализа. На стеке располагается последовательность символов грамматики с маркером конца строки $ на дне. В начале процесса анализа строки стек содержит стартовый нетерминал грамматики непосредственно над символом $. Таблица синтаксического анализа представляет собой двухмерный массив М[X, а], где X — нетерминал, а — терминал или символ $.

Нерекурсивный синтаксический анализатор смотрит на текущий токен строки a и на символ на вершине стека X, а затем принимает решение в зависимости от одного из возникающих ниже случаев:
* если Х=curToken=$, синтаксический анализатор прекращает работу, так как разбор строки завершён,
* eсли Х=curToken≠$, синтаксический анализатор снимает со стека X и перемещает указатель входного потока к следующему токену (то есть вызывает nextToken),
* eсли X представляет собой нетерминал, программа рассматривает запись M[Х,а] таблицы разбора М. Эта запись представляет собой либо X-продукцию грамматики, либо запись об ошибке. Если, например, М[Х,а] = {X → UVW}, синтаксический анализатор замещает X на вершине стека на WVU (с U на вершине стека). В кач-ве выхода синтаксический анализатор просто выводит использованную продукцию. Если M[Х,а] = error, синтаксический анализатор вызывает программу восстановления после ошибки.

=== Псевдокод ===

<code>
function nonRecursiveParser(w : String):
s : Stack
s.push(bottom)
s.push(Start)
do
X = s.top()
if X == c
c = nextToken()
s.pop()
else if X in Sigma
error("unexpected symbol")
else if M[X, c] == undefined // запись об ошибке
error("unexpected symbol")
else if M[X, c] == X -> Y_1 Y_2 ... Y_k
s.pop()
for i = k downto 1
s.push(Y_i)
while s.top() != bottom
</code>

=== Пример ===

<tex>
(1) \ E \to TE' \\
(2) \ E' \to +TE' \\
(3) \ E' \to \varepsilon \\
(4) \ T \to FT' \\
(5) \ T' \to \times FT' \\
(6) \ T' \to \varepsilon \\
(7) \ F \to n \\
(8) \ F \to (E)
</tex>

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"|
!style="background-color:#EEE"| n
!style="background-color:#EEE"| (
!style="background-color:#EEE"| )
!style="background-color:#EEE"| +
!style="background-color:#EEE"| *
!style="background-color:#EEE"| $
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>1 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"| <tex>3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>2 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"| <tex>3 </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>4 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"| <tex>6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>6 </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>8 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>\perp</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|}

[[Файл:Parse_stack.png|500px]]

== Примечания ==
<references/>
== Источники информации ==
* Альфред Ахо, Рави Сети, Джеффри Ульман. Компиляторы. Принципы, технологии, инструменты. Издательство Вильямс. Второе издание. 2008. Стр. 288 {{---}} 294.

[[Категория: Методы трансляции]]
[[Категория: Нисходящий разбор]]

Предиктивный синтаксический анализ

2015-05-25T10:49:10Z

194.85.160.130: /* Общая схема построения рекурсивных парсеров с помощью FIRST и FOLLOW */

{{В разработке}}
Для [[LL(k)-грамматики, множества FIRST и FOLLOW | LL(1)-грамматик]] возможна автоматическая генерация парсеров, если известны множества FIRST и FOLLOW. Существуют общедоступные генераторы: ANTLR<ref>[http://www.antlr.org/ ANTLR {{---}} Parser generator]</ref>, Bison<ref>[http://www.gnu.org/software/bison/ Bison {{---}} GNU Project]</ref>, Yacc<ref>[http://dinosaur.compilertools.net/ Lex & Yacc {{---}} A Lexical Analyzer Generator and Yet Another Compiler-Compiler]</ref>, Happy<ref>[https://www.haskell.org/happy/ Happy {{---}} The Parser Generator for Haskell]</ref>.

== Общая схема построения рекурсивных парсеров с помощью FIRST и FOLLOW ==

Пусть <tex>\Gamma =\langle \Sigma, N, S, P \rangle</tex> {{---}} LL(1)-грамматика. Построим для нее парсер.

Для каждого нетерминала <tex>A : A \rightarrow \alpha_1 \mid \alpha_2 \mid \ldots \mid \alpha_k </tex> создадим функцию <tex> \mathtt{A}() : \mathtt{Node} </tex>, возвращающую фрагмент дерева разбора, выведенный из нетерминала <tex>A</tex>.

Здесь <tex>\mathtt{Node}</tex> {{---}} структура следующего вида:
'''struct''' Node
children : '''list<Node>'''
value : '''string''' // имя нетерминала или текст терминала
'''function''' addChild('''Node''') // функция, подвешивающая поддерево к данному узлу

Каждый момент времени парсер работает с определённым '''токеном''' (англ. ''token'') входного слово <tex>s</tex>. Токен {{---}} один или несколько нетерминалов, для удобства объединяемые по смыслу в одну логическую единицы. Примерами токенов могут выступать следующие лексические единицы:
* произвольный символ <tex> c </tex>,
* целое слово, например <tex> public </tex>,
* число со знаком, обозначаемое далее для краткости как <tex> n </tex>,
В общем случае, токеном может являться любое слово, удовлетворяющее произвольному [[Регулярные языки: два определения и их эквивалентность | регулярному выражению]].

[[Файл:string_token.png|300px]]

В псевдокоде используются следующие обозначения:
* <tex>\mathtt{curToken}</tex> {{---}} текущий токен строки,
* <tex>\mathtt{nextToken()}</tex> {{---}} функция, записывающая в <tex>\mathtt{curToken}</tex> следующий за ним токен.

Тогда шаблон функции рекурсивного парсера для нетерминала <tex>A</tex> имеет вид:

A() : '''Node'''
Node res = Node("A")
'''switch''' (curToken) : // принимаем решение в зависимости от текущего токена строки
'''case''' <tex>\mathrm{FIRST}(\alpha_1) \cup (\mathrm{FOLLOW}(A)\ \mathrm{if}\ \varepsilon \in \mathrm{FIRST}(\alpha_1))</tex> :
// <tex>\alpha_1 = X_1X_2 \ldots X_{t}</tex> 
'''for''' i = 1 .. t
'''if''' <tex> X_i </tex> {{---}} нетерминал
consume(<tex>X_i</tex>)
res.addChild(Node("<tex>X_i</tex>")
nextToken()
'''else''' // <tex>X_i</tex> {{---}} терминал, нужно вызвать 
Node t = <tex>X_i()</tex>
res.addChild(t)
'''break'''
'''case''' <tex>\mathrm{FIRST}(\alpha_2) \cup (\mathrm{FOLLOW}(A)\ \mathrm{if}\ \varepsilon \in \mathrm{FIRST}(\alpha_2))</tex> :
...
'''break'''
...
'''default''' :
error("unexpected char")
'''return''' res

'''function''' consume(c: '''char''')
'''if''' curToken != c
error("expected " + c)
nextToken()

Такой парсер не только разбирает строку, но и находит ошибки в неудовлетворяющих грамматике выражениях.

== Пример ==
Рассмотрим построение парсера на примере LL(1)-грамматики арифметических выражений.

<tex>
E \to TE' \\
E' \to +TE' \mid \varepsilon \\
T \to FT' \\
T' \to \times FT' \mid \varepsilon \\
F \to n \mid (E)
</tex>

Построим для нее множества <tex>FIRST</tex> и <tex>FOLLOW</tex> (их построение подробно разобрано [[Построение FIRST и FOLLOW#Пример | здесь]]).

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Правило
!style="background-color:#EEE"| FIRST
!style="background-color:#EEE"| FOLLOW
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \varepsilon\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ ,\ )\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \times,\ \varepsilon\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ ,\ )\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \times, \ +,\ \$\ ,\ )\ \} </tex>
|}

=== Псевдокоды ===
Построим функции обработки некоторых нетерминалов.

E()
res = Node("E")
switch(curToken)
case 'n', '(' :
res.addChild(T())
res.addChild(E'())
break
default :
error("unexpected char")
return res

E'()
res = Node("E'")
switch(curToken)
case '+' :
consume('+')
res.addChild(Node("+"))
res.addChild(T())
res.addChild(E'())
break
case '$', ')' :
break
default :
error("unexpected char")
return res

F()
res = Node("F")
switch(curToken)
case 'n' :
consume('n')
res.addChild(Node("n"))
break
case '(' :
consume('(')
res.addChild(Node("("))
res.addChild(E())
consume(')')
res.addChild(Node(")"))
default :
error("unexpected char")
return res

Функции для <tex>T</tex> и <tex>T'</tex> строятся аналогично.

=== Дерево разбора ===

Рассмотрим дерево разбора для выражения (1 + 2) * 3 и несколько первых шагов алгоритма рекурсивного разбора. Сначала вызывается функция стартового нетерминала грамматики, то есть <tex>E</tex>. Так как первым токеном является '(', то будет использовано первое правило разбора <tex>TE'</tex>. Поэтому к вершине с меткой <tex>E</tex> добавятся два ребёнка: <tex>T</tex> и <tex>E'</tex>. А рекурсивный разборщик перейдёт к нетерминалу <tex>T</tex>. По-прежнему curToken равен '(', поэтому в <tex>F</tex> сработает второй case, первым ребёнком добавится '(', curToken станет равен <tex>1</tex>, а разборщик перейдёт к нетерминалу <tex>E</tex>. После того как выражение после '(', которое выводится из <tex>E</tex>, будет полностью разобрано, функция рекурсивного разбора для <tex>F</tex> добавит ')' последним сыном к этому нетерминалу.

Продолжая в том же духе, мы построим всё дерево разбора данного выражения.

[[Файл:parse_ex1.png|400px|thumb|center|Дерево разбора выражения (1 + 2) * 3]]

== Нерекурсивный нисходящий парсер ==

[[Файл:Parse_table.png|350px|right]]

Рекурсивные разборщики можно генерировать автоматически, зная множества FIRST и FOLLOW, так как они имеют достаточно прозрачный шаблон построения. Альтернативным способом осуществления нисходящего синтаксического анализа является построение нерекурсивного нисходящего парсера. Его можно построить с помощью явного использования стека (вместо неявного при рекурсивных вызовах). Такое анализатор имитирует левое порождение.

Нерекурсивный предиктивный синтаксический анализатор содержит дополнительно стек, содержащий последовательность терминалов и нетерминалов, и таблицу синтаксического анализа. На стеке располагается последовательность символов грамматики с маркером конца строки $ на дне. В начале процесса анализа строки стек содержит стартовый нетерминал грамматики непосредственно над символом $. Таблица синтаксического анализа представляет собой двухмерный массив М[X, а], где X — нетерминал, а — терминал или символ $.

Нерекурсивный синтаксический анализатор смотрит на текущий токен строки a и на символ на вершине стека X, а затем принимает решение в зависимости от одного из возникающих ниже случаев:
* если Х=curToken=$, синтаксический анализатор прекращает работу, так как разбор строки завершён,
* eсли Х=curToken≠$, синтаксический анализатор снимает со стека X и перемещает указатель входного потока к следующему токену (то есть вызывает nextToken),
* eсли X представляет собой нетерминал, программа рассматривает запись M[Х,а] таблицы разбора М. Эта запись представляет собой либо X-продукцию грамматики, либо запись об ошибке. Если, например, М[Х,а] = {X → UVW}, синтаксический анализатор замещает X на вершине стека на WVU (с U на вершине стека). В кач-ве выхода синтаксический анализатор просто выводит использованную продукцию. Если M[Х,а] = error, синтаксический анализатор вызывает программу восстановления после ошибки.

=== Псевдокод ===

<code>
function nonRecursiveParser(w : String):
s : Stack
s.push(bottom)
s.push(Start)
do
X = s.top()
if X == c
c = nextToken()
s.pop()
else if X in Sigma
error("unexpected symbol")
else if M[X, c] == undefined // запись об ошибке
error("unexpected symbol")
else if M[X, c] == X -> Y_1 Y_2 ... Y_k
s.pop()
for i = k downto 1
s.push(Y_i)
while s.top() != bottom
</code>

=== Пример ===

<tex>
(1) \ E \to TE' \\
(2) \ E' \to +TE' \\
(3) \ E' \to \varepsilon \\
(4) \ T \to FT' \\
(5) \ T' \to \times FT' \\
(6) \ T' \to \varepsilon \\
(7) \ F \to n \\
(8) \ F \to (E)
</tex>

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"|
!style="background-color:#EEE"| n
!style="background-color:#EEE"| (
!style="background-color:#EEE"| )
!style="background-color:#EEE"| +
!style="background-color:#EEE"| *
!style="background-color:#EEE"| $
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>1 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"| <tex>3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>2 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"| <tex>3 </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>4 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"| <tex>6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>6 </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>8 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>\perp</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|}

[[Файл:Parse_stack.png|500px]]

== Примечания ==
<references/>
== Источники информации ==
* Альфред Ахо, Рави Сети, Джеффри Ульман. Компиляторы. Принципы, технологии, инструменты. Издательство Вильямс. Второе издание. 2008. Стр. 288 {{---}} 294.

[[Категория: Методы трансляции]]
[[Категория: Нисходящий разбор]]

Предиктивный синтаксический анализ

2015-05-25T10:40:06Z

194.85.160.130: /* Общая схема построения рекурсивных парсеров с помощью FIRST и FOLLOW */

{{В разработке}}
Для [[LL(k)-грамматики, множества FIRST и FOLLOW | LL(1)-грамматик]] возможна автоматическая генерация парсеров, если известны множества FIRST и FOLLOW. Существуют общедоступные генераторы: ANTLR<ref>[http://www.antlr.org/ ANTLR {{---}} Parser generator]</ref>, Bison<ref>[http://www.gnu.org/software/bison/ Bison {{---}} GNU Project]</ref>, Yacc<ref>[http://dinosaur.compilertools.net/ Lex & Yacc {{---}} A Lexical Analyzer Generator and Yet Another Compiler-Compiler]</ref>, Happy<ref>[https://www.haskell.org/happy/ Happy {{---}} The Parser Generator for Haskell]</ref>.

== Общая схема построения рекурсивных парсеров с помощью FIRST и FOLLOW ==

Пусть <tex>\Gamma =\langle \Sigma, N, S, P \rangle</tex> {{---}} LL(1)-грамматика. Построим для нее парсер.

Для каждого нетерминала <tex>A : A \rightarrow \alpha_1 \mid \alpha_2 \mid \ldots \mid \alpha_k </tex> создадим функцию <tex> \mathtt{A}() : \mathtt{Node} </tex>, возвращающую фрагмент дерева разбора, выведенный из нетерминала <tex>A</tex>.

Здесь <tex>\mathtt{Node}</tex> {{---}} структура следующего вида:
'''struct''' Node
children : '''list<Node>'''
value : '''string''' // имя нетерминала или текст терминала
'''function''' addChild('''Node''') // функция, подвешивающая поддерево к данному узлу

Каждый момент времени парсер работает с определённым '''токеном''' (англ. ''token'') входного слово <tex>s</tex>. Токен {{---}} один или несколько нетерминалов, для удобства объединяемые по смыслу в одну логическую единицы. Примерами токенов могут выступать следующие лексические единицы:
* произвольный символ <tex> c </tex>,
* целое слово, например <tex> public </tex>,
* число со знаком, обозначаемое далее для краткости как <tex> n </tex>,
В общем случае, токеном может являться любое слово, удовлетворяющее произвольному [[Регулярные языки: два определения и их эквивалентность | регулярному выражению]].

[[Файл:string_token.png|300px]]

В псевдокоде используются следующие обозначения:
* <tex>\mathtt{curToken}</tex> {{---}} текущий токен строки,
* <tex>\mathtt{nextToken()}</tex> {{---}} функция, записывающая в <tex>\mathtt{curToken}</tex> следующий за ним токен.

Тогда шаблон функции рекурсивного парсера для нетерминала <tex>A</tex> имеет вид:

A() : '''Node'''
Node res = Node("A")
'''switch''' (curToken) : // принимаем решение в зависимости от текущего токена строки
'''case''' <tex>\mathrm{FIRST}(\alpha_1) \cup (\mathrm{FOLLOW}(A)\ \mathrm{if}\ \varepsilon \in \mathrm{FIRST}(\alpha_1))</tex> :
// <tex>\alpha_1 = X_1X_2 \ldots X_{t}</tex> 
'''for''' i = 1 .. t
'''if''' <tex> X_i </tex> {{---}} нетерминал
consume(<tex>X_i</tex>)
res.addChild(Node("<tex>X_i</tex>")
nextToken()
'''else''' // <tex>X_i</tex> {{---}} терминал, нужно вызвать 
Node t = <tex>X_i()</tex>
res.addChild(t)
'''break'''
'''case''' <tex>\mathrm{FIRST}(\alpha_2) \cup (\mathrm{FOLLOW}(A)\ \mathrm{if}\ \varepsilon \in \mathrm{FIRST}(\alpha_2))</tex> :
...
'''break'''
...
'''default''' :
error("unexpected char")
'''return''' res

'''function''' consume(c: '''char''')
'''if''' curToken != c
error("expected " + c)
nextToken()

Такой парсер не только разбирает строку, но и находит ошибки в неудовлетворяющих грамматике выражениях.

== Пример ==
Рассмотрим построение парсера на примере LL(1)-грамматики арифметических выражений.

<tex>
E \to TE' \\
E' \to +TE' \mid \varepsilon \\
T \to FT' \\
T' \to \times FT' \mid \varepsilon \\
F \to n \mid (E)
</tex>

Построим для нее множества <tex>FIRST</tex> и <tex>FOLLOW</tex> (их построение подробно разобрано [[Построение FIRST и FOLLOW#Пример | здесь]]).

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Правило
!style="background-color:#EEE"| FIRST
!style="background-color:#EEE"| FOLLOW
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \varepsilon\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ ,\ )\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \times,\ \varepsilon\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ ,\ )\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \times, \ +,\ \$\ ,\ )\ \} </tex>
|}

=== Псевдокоды ===
Построим функции обработки некоторых нетерминалов.

E()
res = Node("E")
switch(curToken)
case 'n', '(' :
res.addChild(T())
res.addChild(E'())
break
default :
error("unexpected char")
return res

E'()
res = Node("E'")
switch(curToken)
case '+' :
consume('+')
res.addChild(Node("+"))
res.addChild(T())
res.addChild(E'())
break
case '$', ')' :
break
default :
error("unexpected char")
return res

F()
res = Node("F")
switch(curToken)
case 'n' :
consume('n')
res.addChild(Node("n"))
break
case '(' :
consume('(')
res.addChild(Node("("))
res.addChild(E())
consume(')')
res.addChild(Node(")"))
default :
error("unexpected char")
return res

Функции для <tex>T</tex> и <tex>T'</tex> строятся аналогично.

=== Дерево разбора ===

Рассмотрим дерево разбора для выражения (1 + 2) * 3 и несколько первых шагов алгоритма рекурсивного разбора. Сначала вызывается функция стартового нетерминала грамматики, то есть <tex>E</tex>. Так как первым токеном является '(', то будет использовано первое правило разбора <tex>TE'</tex>. Поэтому к вершине с меткой <tex>E</tex> добавятся два ребёнка: <tex>T</tex> и <tex>E'</tex>. А рекурсивный разборщик перейдёт к нетерминалу <tex>T</tex>. По-прежнему curToken равен '(', поэтому в <tex>F</tex> сработает второй case, первым ребёнком добавится '(', curToken станет равен <tex>1</tex>, а разборщик перейдёт к нетерминалу <tex>E</tex>. После того как выражение после '(', которое выводится из <tex>E</tex>, будет полностью разобрано, функция рекурсивного разбора для <tex>F</tex> добавит ')' последним сыном к этому нетерминалу.

Продолжая в том же духе, мы построим всё дерево разбора данного выражения.

[[Файл:parse_ex1.png|400px|thumb|center|Дерево разбора выражения (1 + 2) * 3]]

== Нерекурсивный нисходящий парсер ==

[[Файл:Parse_table.png|350px|right]]

Рекурсивные разборщики можно генерировать автоматически, зная множества FIRST и FOLLOW, так как они имеют достаточно прозрачный шаблон построения. Альтернативным способом осуществления нисходящего синтаксического анализа является построение нерекурсивного нисходящего парсера. Его можно построить с помощью явного использования стека (вместо неявного при рекурсивных вызовах). Такое анализатор имитирует левое порождение.

Нерекурсивный предиктивный синтаксический анализатор содержит дополнительно стек, содержащий последовательность терминалов и нетерминалов, и таблицу синтаксического анализа. На стеке располагается последовательность символов грамматики с маркером конца строки $ на дне. В начале процесса анализа строки стек содержит стартовый нетерминал грамматики непосредственно над символом $. Таблица синтаксического анализа представляет собой двухмерный массив М[X, а], где X — нетерминал, а — терминал или символ $.

Нерекурсивный синтаксический анализатор смотрит на текущий токен строки a и на символ на вершине стека X, а затем принимает решение в зависимости от одного из возникающих ниже случаев:
* если Х=curToken=$, синтаксический анализатор прекращает работу, так как разбор строки завершён,
* eсли Х=curToken≠$, синтаксический анализатор снимает со стека X и перемещает указатель входного потока к следующему токену (то есть вызывает nextToken),
* eсли X представляет собой нетерминал, программа рассматривает запись M[Х,а] таблицы разбора М. Эта запись представляет собой либо X-продукцию грамматики, либо запись об ошибке. Если, например, М[Х,а] = {X → UVW}, синтаксический анализатор замещает X на вершине стека на WVU (с U на вершине стека). В кач-ве выхода синтаксический анализатор просто выводит использованную продукцию. Если M[Х,а] = error, синтаксический анализатор вызывает программу восстановления после ошибки.

=== Псевдокод ===

<code>
function nonRecursiveParser(w : String):
s : Stack
s.push(bottom)
s.push(Start)
do
X = s.top()
if X == c
c = nextToken()
s.pop()
else if X in Sigma
error("unexpected symbol")
else if M[X, c] == undefined // запись об ошибке
error("unexpected symbol")
else if M[X, c] == X -> Y_1 Y_2 ... Y_k
s.pop()
for i = k downto 1
s.push(Y_i)
while s.top() != bottom
</code>

=== Пример ===

<tex>
(1) \ E \to TE' \\
(2) \ E' \to +TE' \\
(3) \ E' \to \varepsilon \\
(4) \ T \to FT' \\
(5) \ T' \to \times FT' \\
(6) \ T' \to \varepsilon \\
(7) \ F \to n \\
(8) \ F \to (E)
</tex>

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"|
!style="background-color:#EEE"| n
!style="background-color:#EEE"| (
!style="background-color:#EEE"| )
!style="background-color:#EEE"| +
!style="background-color:#EEE"| *
!style="background-color:#EEE"| $
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>1 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"| <tex>3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>2 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"| <tex>3 </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>4 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"| <tex>6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>6 </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>8 </tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>\perp</tex>
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|style="background-color:#FFF;padding:2px 30px"|
|}

[[Файл:Parse_stack.png|500px]]

== Примечания ==
<references/>
== Источники информации ==
* Альфред Ахо, Рави Сети, Джеффри Ульман. Компиляторы. Принципы, технологии, инструменты. Издательство Вильямс. Второе издание. 2008. Стр. 288 {{---}} 294.

[[Категория: Методы трансляции]]
[[Категория: Нисходящий разбор]]

Предиктивный синтаксический анализ

2015-05-25T09:44:34Z

194.85.160.130:

Список заданий по АСД сем2

2015-03-05T10:15:22Z

194.85.160.130:

<wikitex>
= Дискретная математика, алгоритмы и структуры данных, 4 семестр =

# Бордером строки называется строка, которая является одновременно ее префиксом и суффиксом. Периодом строки $s$ называется число $p$, такое что для всех допустимых $i$ выполнено $s[i+p]=s[i]$. Докажите, что если у строки длины $n$ есть border длины $k$, то у нее есть период $n - k$.
# Докажите, что если у строки есть периоды $p$ и $q$, причем $p + q \le n$, то $gcd(p, q)$ также является периодом этой строки.
# Что будет, если в предыдущем задании убрать условие $p + q \le n$?
# Строки Фибоначчи. Определим $F_0 = \varepsilon$, $F_1 = b$, $F_2 = a$, $F_n = F_{n-1} F_{n-2}$. Докажите, что существует $k$ такое, что для $n \ge k$ выполнено $F_n^2$ - префикс $F_{n+2}$.
# Докажите, что существует $k$ такое, что если $n \ge k$, то строка $F_n[1...|F_n|-2]$ - палиндром.
# Определим строку Туе-Морса: $T_n = t_0t_1t_2...t_{2^n - 1}$, где $t_i = 0$, если двоичная запись числа $i$ содержит четное число единиц, и $t_i = 1$ в противном случае. Доказать, что не существует двух равных как строки подстрок строки $T_n$, имеющих пересекающиеся вхождения в $T_n$
# Докажите, что для любого $u \ne \varepsilon$ и любого $n$ строка $u^3$ - не подстрока $T_n$
# Разработать алгоритм восстановления строки по префикс-функции. ($O(n)$ или $O(n \log n)$, алфавит неограничен)
# Разработать алгоритм восстановления строки по z-функции. ($O(n)$ или $O(n \log n)$, алфавит неограничен)
# Разработать алгоритм восстановления строки по z-функции. ($O(n)$ или $O(n \log n)$, алфавит двоичный)
# Вычислить $z$-функцию по префикс функции. ($O(n)$ или $O(n \log n)$, алфавит неограничен, не прибегать к промежуточному представлению в виде строки)
# Вычислить префикс функцию по $z$-функции. ($O(n)$ или $O(n \log n)$, алфавит неограничен, не прибегать к промежуточному представлению в виде строки)
# Как найти строку длины $m$ в строке длины $n$ с использованием z-функции и O(m) дополнительной памяти?
# Задана строка. Пусть $p_1[i]$ - максимальная длина палиндрома нечетной длины с центром в позиции $i$. $p_0[i]$ - аналогично для четной длины. Модифицировать алгоритм поиска $z$-функции для построения $p_0$ и $p_1$.
# Дана строка $s$. Посчитать матрицу $A: ||a_{ij}|| = LCP(s[i .. n-1], s[j .. n-1])$; $i,j \ge 0$ за $O(|s|^2)$. (LCP - наибольший общий префикс двух строк)
# Докажите, что в конечном автомате для поиска подстроки в строке длины $n$ лишь $O(n)$ ребер ведут не в начальное состояние. Как это помогает сэкономить память?
# Алгоритм Саймона. Используя результат предыдущего задания, предложите алгоритм построения автомата за $O(n)$ (без множителя, зависящего от размера алфавита).
# Дана строка $s$. Посчитать число строк длины $L$, содержащих $s$ как подстроку. Время работы должно быть полиномом от длины $s$, и $L$.
# Дана строка $s$. Посчитать число строк длины $L$, содержащих $s$ как подстроку (по заданному модулю). Время работы должно быть полиномом от длины $s$, и $\log L$.
# Дана строка $s$. Посчитать число строк длины $l$, содержащих не менее $k$ вхождений $s$.
# Дана строка $s$. Посчитать число строк длины $l$, содержащих не менее $k$ непересекающихся вхождений $s$.
# Это и следующее задание доказывают линейность алгоритма Апостолико-Джанкарло. Будем обозначать закешированные значения наибольшего суффикса образца, который заканчивается в i-й позиции текста как suf[i]. Будем называть отрезок текста [i-suf[i]+1 - i] покрытым. Докажите, что любые два покрытых отрезка в процессе работы алгоритма либо вложены, либо не пересекаются.
# Используя результат предыдещего задания, докажите, что алгоритм Апостолико-Джанкарло работает линейное время.
# Докажите, что если строки s и t таковы, что st=ts, то найдется такая строка p, что $s=p^i$ и $t=p^j$ для некоторых i и j.
# Модифицировать алгоритм Ахо-Корасик так, чтобы не хранить все переходы, а только исходный бор и суффиксные ссылки, и время работы осталось прежним.
# Найти первые вхождения каждого из образцов в тексте за время O(длина текста + постр. автомата).
# Дано 2 бора A и B. Для всех вершин $u$ в $A$ найти самую глубокую вершину $v$ в $B$, соответствующую суффиксу $u$ (префикс-функция бора в боре). $O(|A| + |B|)$
# Дан набор образцов $\{p_i\}$. Определить, существует ли бесконечная вправо строка $t$, не содержащая $p_i$ как подстроки.
# Дан набор образцов $\{p_i\}$. Определить, существует ли бесконечная в две стороны строка $t$, не содержащая $p_i$ как подстроки.
# Дан набор образцов $\{p_i\}$. Посчитать число строк длины $l$, содержащих хотя бы одну из $p_i$ как подстроку. $O(\sum |p_i|\cdot l\cdot \sigma)$. ($\sigma$ - размер алфавита)

</wikitex>

Минимизация ДКА, алгоритм Хопкрофта (сложность O(n log n))

2014-01-22T08:36:42Z

194.85.160.130: /* Простой алгоритм */

Пусть дан автомат, распознающий определенный язык. Требуется найти [[ Эквивалентность_состояний_ДКА | эквивалентный автомат]] с наименьшим количеством состояний.

== Минимизация ДКА ==
Если в ДКА существуют два [[ Эквивалентность_состояний_ДКА | эквивалентных состояния]], то при их объединении мы получим [[ Эквивалентность_состояний_ДКА | эквивалентный ДКА]], так как распознаваемый язык не изменится. Основная идея минимизации состоит в разбиении множества состояний на классы эквивалентности, полученные классы и будут состояниями минимизированного ДКА.

== Простой алгоритм ==
{{Определение
|definition =
Класс <tex>C</tex> '''разбивает''' класс <tex>R</tex> по символу <tex>a</tex> на <tex>R_1</tex> и <tex>R_2</tex>, если
# <tex>\forall r \in R_1 \,\,\, \delta(r, a) \in C</tex>
# <tex>\forall r \in R_2 \,\,\, \delta(r, a) \notin C</tex>
}}
Если класс <tex>R</tex> может быть разбит по символу <tex>a</tex>, то он содержит хотя бы одну пару неэквивалентных состояний (так как существует строка которая их различает). Если класс нельзя разбить, то он состоит из эквивалентных состояний.
Поэтому самый простой алгоритм состоит в том, чтобы разбивать классы текущего разбиения до тех пор пока это возможно.

Итеративно строим разбиение множества состояний следующим образом.
# Первоначальное разбиение множества состояний {{---}} класс допускающих состояний <tex>F</tex> и класс недопускающих состояний <tex>Q \setminus F</tex>.
# Перебираются символы алфавита <tex>c \in \Sigma</tex>, все пары <tex>(F, c)</tex> и <tex>(Q \setminus F, c)</tex> помещаются в очередь.
# Из очереди извлекается пара <tex>(C, a)</tex>, <tex>C</tex> далее именуется как мастер Сплиттер.
# Все классы текущего разбиения разбиваются на 2 подкласса (один из которых может быть пустым). Первый состоит из состояний, которые по символу <tex>a</tex> переходят в сплиттер, а второй из всех оставшихся.
# Те классы, которые разбились на два непустых подкласса, заменяются этими подклассами в разбиении, а также добавляются в очередь.
# Пока очередь не пуста, выполняем п.3 – п.5.

===Псевдокод===
<tex>Q</tex> {{---}} множество состояний ДКА.
<tex>F</tex> {{---}} множество терминальных состояний.
<tex>S</tex> {{---}} очередь пар <tex>(C, a)</tex>.
<tex>P</tex> {{---}} разбиение множества состояний ДКА.
<tex>R</tex> {{---}} класс состояний ДКА.
<tex>\mathtt{P} \leftarrow \{ \mathtt{F, Q} \setminus \mathtt{F} \}</tex>
<tex>\mathtt{S} \leftarrow \varnothing </tex>
'''for''' <tex>c \in \Sigma</tex>
'''insert''' <tex>(\mathtt{F}, c)</tex> '''in''' <tex>\mathtt{S}</tex>
'''insert''' <tex>(\mathtt{Q} \setminus \mathtt{F}, c)</tex> '''in''' <tex>\mathtt{S}</tex>
'''while''' <tex> \mathtt{S} \ne \varnothing </tex>
<tex>(C, a) \leftarrow</tex> '''pop'''(<tex>\mathtt{S}</tex>)
'''for''' <tex>R</tex> '''in''' <tex>\mathtt{P}</tex>
<tex>R_1 = R \cap \delta^{-1} (C, a) </tex>
<tex>R_2 = R \setminus R_1</tex>
'''if''' <tex> R_1 \ne \varnothing </tex> '''and''' <tex> R_2 \ne \varnothing </tex>
'''replace''' <tex>R</tex> '''in''' <tex>\mathtt{P}</tex> '''with''' <tex>R_1</tex> '''and''' <tex>R_2</tex>
'''for''' <tex> c \in \Sigma </tex>
'''insert''' <tex>(R_1, c)</tex> '''in''' <tex>\mathtt{S}</tex>
'''insert''' <tex>(R_2, c)</tex> '''in''' <tex>\mathtt{S}</tex>
Когда очередь <tex>S</tex> станет пустой, будет получено разбиение на классы эквивалентности, так как больше ни один класс невозможно разбить.

===Время работы===
Время работы алгоритма оценивается как <tex>O(|\Sigma| \cdot n^2)</tex>, где <tex> n </tex> {{---}} количество состояний ДКА, а <tex> \Sigma </tex>{{---}} алфавит. Это следует из того, что если пара <tex>(C, a)</tex> попала в очередь, и класс <tex>C</tex> использовался в качестве сплиттера, то при последующем разбиении этого класса в очередь добавляется два класса <tex>C_1</tex> и <tex>C_2</tex>, причем можно гарантировать лишь следующее уменьшение размера: <tex>|C| \ge |C_i| + 1</tex>. Каждое состояние изначально принадлежит лишь одному классу в очереди, поэтому каждый переход в автомате будет просмотрен не более, чем <tex>O(n)</tex> раз. Учитывая, что ребер всего <tex>O(|\Sigma| \cdot n)</tex>, получаем указанную оценку.

== Алгоритм Хопкрофта==

{{Лемма
|statement = Класс <tex>R = R_1 \cup R_2</tex> и <tex>R_1 \cap R_2 = \varnothing</tex>, тогда разбиение всех классов (текущее разбиение) по символу <tex>a</tex> любыми двумя классами из <tex>R, R_1, R_2</tex> эквивалентно разбиению всех классов с помощью <tex>R, R_1, R_2</tex> по символу <tex>a</tex>.
|proof =
Разобьем все классы с помощью <tex>R </tex> и <tex> R_1</tex> по символу <tex>a</tex>, тогда для любого класса <tex>B</tex> из текущего разбиения выполняется
:<tex>\forall r \in B \,\,\, \delta(r, a) \in R</tex> and <tex> \delta(r, a) \in R_1</tex> or
:<tex>\forall r \in B \,\,\, \delta(r, a) \in R</tex> and <tex> \delta(r, a) \notin R_1</tex> or
:<tex>\forall r \in B \,\,\, \delta(r, a) \notin R</tex> and <tex> \delta(r, a) \notin R_1</tex>
А так как <tex>R = R_1 \cup R_2</tex> и <tex>R_1 \cap R_2 = \varnothing</tex> то выполняется
:<tex>\forall r \in B \,\,\, \delta(r, a) \in R_2 </tex> or
:<tex> \forall r \in B \,\,\, \delta(r, a) \notin R_2</tex>
Из этого следует, что разбиение всех классов с помощью <tex>R_2</tex> никак не повлияет на текущее разбиение. 
Аналогично доказывается и для разбиения с помощью <tex>R </tex> и <tex> R_2</tex> по символу <tex>a</tex>. 
Разобьем все классы с помощью <tex>R_1</tex> и <tex> R_2</tex> по символу <tex>a</tex>, тогда для любого класса <tex>B</tex> из текущего разбиения выполняется
:<tex>\forall r \in B \,\,\, \delta(r, a) \in R_1</tex> and <tex> \delta(r, a) \notin R_2</tex> or
:<tex>\forall r \in B \,\,\, \delta(r, a) \notin R_1</tex> and <tex> \delta(r, a) \in R_2</tex> or
:<tex>\forall r \in B \,\,\, \delta(r, a) \notin R_1</tex> and <tex> \delta(r, a) \notin R_2</tex>
А так как <tex>R = R_1 \cup R_2</tex> и <tex>R_1 \cap R_2 = \varnothing</tex> то выполняется
:<tex>\forall r \in B \,\,\, \delta(r, a) \in R </tex> or
:<tex> \forall r \in B \,\,\, \delta(r, a) \notin R</tex>
Из этого следует, что разбиение всех классов с помощью <tex>R</tex> никак не повлияет на текущее разбиение.
}}

Алгоритм Хопкрофта отличается от простого тем, что иначе добавляет классы в очередь.
Если класс <tex>R</tex> уже есть в очереди, то согласно лемме можно просто заменить его на <tex>R_1</tex> и <tex>R_2</tex>.
Если класса <tex>R</tex> нет в очереди, то согласно лемме в очередь можно добавить класс <tex>R</tex> и любой из <tex>R_1</tex> и <tex>R_2</tex>, а так как для любого класса <tex>B</tex> из текущего разбиения выполняется
:<tex>\forall r \in B \,\,\, \delta(r, a) \in R </tex> or
:<tex> \forall r \in B \,\,\, \delta(r, a) \notin R</tex>
то в очередь можно добавить только меньшее из <tex>R_1</tex> и <tex>R_2</tex>.

===Реализация===
<tex>Q</tex> {{---}} множество состояний ДКА.
<tex>F</tex> {{---}} множество терминальных состояний.
<tex>S</tex> {{---}} очередь из пар <tex>(C, a)</tex>.
<tex>P</tex> {{---}} разбиение множества состояний ДКА.
<tex>R</tex> {{---}} класс состояний ДКА.

<tex>\mathtt{P} \leftarrow \{ \mathtt{F, Q} \setminus \mathtt{F} \}</tex>
<tex>\mathtt{S} \leftarrow \varnothing </tex>
'''for''' <tex>c \in \Sigma</tex>
'''insert''' <tex> (\mathtt{min} (\mathtt{F, Q} \setminus \mathtt{F}), c)</tex> '''in''' <tex>\mathtt{S}</tex>
'''while''' <tex>\mathtt{S} \ne \varnothing</tex>
<tex>(C, a) \leftarrow</tex> '''pop'''(<tex>\mathtt{S}</tex>)
<tex>T \leftarrow \{R \ | \ R \in \mathtt{P}, \ R</tex> splits by <tex>(C, a) \}</tex>
'''for each''' <tex>R</tex> '''in''' <tex>T</tex>
<tex> R_1, R_2 \leftarrow </tex> '''split'''(<tex>R, C, a</tex>)
'''replace''' <tex>R</tex> '''in''' <tex>\mathtt{P}</tex> '''with''' <tex>R_1</tex> '''and''' <tex>R_2</tex>
'''for''' <tex>c \in \Sigma</tex>
'''if''' <tex>(R, c)</tex> '''in''' <tex>\mathtt{S}</tex>
'''replace''' <tex> (R, c)</tex> '''in''' <tex>\mathtt{S}</tex> '''with''' <tex>(R_1, c)</tex> '''and''' <tex>(R_2, c)</tex>
'''else'''
'''insert''' <tex>(\mathtt{min}(R_1, R_2), c)</tex> '''in''' <tex>\mathtt{S}</tex>

К сожалению, совсем не очевидно, как быстро находить множество <tex>T</tex>. С другой стороны, понятно, что <tex>T \subset T'</tex>, где <tex>T'</tex> {{---}} это множество классов текущего разбиения, из состояний которых в автомате существует переход в состояния сплиттера <tex>C</tex> по символу <tex>a</tex>.

Модифицируем наш алгоритм: для каждой очередной пары <tex> (C, a) </tex> будем находить <tex> T' </tex>, и с каждым классом состояний из <tex> T' </tex> будем производить те же действия, что и раньше.

<tex>\mathtt{P} \leftarrow \{ \mathtt{F, Q} \setminus \mathtt{F} \}</tex>
<tex>\mathtt{S} \leftarrow \varnothing </tex>
'''for''' <tex>c \in \Sigma</tex>
'''insert''' <tex>(\mathtt{min} (\mathtt{F, Q} \setminus \mathtt{F}), c)</tex> '''in''' <tex>\mathtt{S}</tex>
'''while''' <tex>\mathtt{S} \ne \varnothing</tex>
<tex>(C, a) \leftarrow</tex> '''pop'''(<tex>\mathtt{S}</tex>)
<tex>\mathtt{Inverse} \leftarrow \{r \ | \ r \in \mathtt{Q}, \ \delta(r, a) \in C\}</tex>
<tex>T' \leftarrow \{R \ | \ R \in \mathtt{P}, \ R \cap \mathtt{Inverse} \neq \varnothing\}</tex>
'''for each''' <tex>R</tex> '''in''' <tex>T'</tex>
'''if''' <tex>R</tex> splits by <tex>(C, a)</tex>
<tex> R_1, R_2 \leftarrow </tex> '''split'''(<tex>R, C, a</tex>)
'''replace''' <tex>R</tex> '''in''' <tex>\mathtt{P}</tex> '''with''' <tex>R_1</tex> '''and''' <tex>R_2</tex>
'''for''' <tex>c \in \Sigma</tex>
'''if''' <tex>(R, c)</tex> '''in''' <tex>\mathtt{S}</tex>
'''replace''' <tex>(R, c)</tex> '''in''' <tex>S</tex> '''with''' <tex>(R_1, c)</tex> '''and''' <tex>(R_2, c)</tex>
'''else'''
'''insert''' <tex>(\mathtt{min}(R_1, R_2), c)</tex> '''in''' <tex>\mathtt{S}</tex>

Каждая итерация цикла <tex> while </tex> не может быть выполнена быстрее, чем за <tex> O(|\mathtt{Inverse}|) </tex> для текущей пары <tex> (C,a)</tex>. Покажем, как достичь этой оценки.

Разбиение <tex> P </tex> можно поддерживать четырьмя массивами:
*<tex>\mathtt{Class}[r]</tex> {{---}} номер класса, которому принадлежит состояние <tex>r</tex>;
*<tex>\mathtt{Part}[i]</tex> {{---}} указатель на голову [[Список#Двусвязный список|двусвязного списка]], содержащего состояния, принадлежащие классу <tex> i </tex>;
*<tex>\mathtt{Card}[i]</tex> {{---}} количество состояний в классе <tex>i</tex>;
*<tex>\mathtt{Place}[r]</tex> {{---}} указатель на состояние <tex>r</tex> в списке <tex>\mathtt{Part[Class}[r]]</tex>.

Так как мы храним указатель, где находится состояние в двусвязном списке, то операцию перемещения состояния из одного класса в другой можно выполнить за <tex>O(1)</tex>.

Чтобы эффективно находить множество <tex>\mathtt{Inverse}</tex>, построим массив <tex>\mathtt{Inv}</tex>, который для состояния <tex>r</tex> и символа <tex>a</tex> в <tex>\mathtt{Inv}[r][a]</tex> хранит множество состояний, из которых существует переход в <tex>r</tex> по символу <tex>a</tex>. Так как наш алгоритм не меняет изначальный автомат, то массив <tex>\mathtt{Inv}</tex> можно построить перед началом основной части алгоритма, что займет <tex>O(|\Sigma| |Q|)</tex> времени.

Теперь научимся за <tex>O(|\mathtt{Inverse}|)</tex> обрабатывать множество <tex>T'</tex> и разбивать классы. Для этого нам понадобится следующая структура:
*<tex>\mathtt{Counter}</tex> {{---}} количество классов;
*<tex>\mathtt{Involved}</tex> {{---}} список из номеров классов, содержащихся во множестве <tex>T'</tex>;
*<tex>\mathtt{Size}</tex> {{---}} целочисленный массив, где <tex>\mathtt{Size}[i]</tex> хранит количество состояний из класса <tex>i</tex>, которые содержатся в <tex>\mathtt{Inverse}</tex>;
*<tex>\mathtt{Twin}</tex> {{---}} массив, хранящий в <tex>\mathtt{Twin}[i]</tex> номер нового класса, образовавшегося при разбиении класса <tex>i</tex>.

Сам же алгоритм обработки <tex>T'</tex> будет выглядеть так:
<tex>\mathtt{Involved} \leftarrow \varnothing</tex>
'''for''' <tex>q \in C</tex> '''and''' <tex>r \in \mathtt{Inv}[q][a]</tex>
<tex>i = \mathtt{Class}[q]</tex>
'''if''' <tex>\mathtt{Size}[i] == 0</tex>
'''insert''' <tex>i</tex> '''in''' <tex>\mathtt{Involved}</tex>
<tex>\mathtt{Size}[i]++</tex>
'''for''' <tex>q \in C</tex> '''and''' <tex>r \in \mathtt{Inv}[q][a]</tex>
<tex>i = \mathtt{Class}[q]</tex>
'''if''' <tex>\mathtt{Size}[i] < \mathtt{Card}[i]</tex>
'''if''' <tex>\mathtt{Twin}[i] == 0</tex>
<tex>\mathtt{Counter}++</tex>
<tex>\mathtt{Twin[i]} = \mathtt{Counter}</tex>
'''move''' <tex>r</tex> '''from''' <tex>i</tex> '''to''' <tex>\mathtt{Twin}[i]</tex>
'''for''' <tex> j \in \mathtt{Involved}</tex>
<tex>\mathtt{Size}[j] = 0</tex>
<tex>\mathtt{Twin}[j] = 0</tex>

Для быстрой проверки, находится ли пара <tex>(C,a)</tex> в очереди <tex>S</tex>, будем использовать массив <tex>\mathtt{InQueue}</tex> размера <tex>|Q| \times |\Sigma|</tex>, где <tex>\mathtt{InQueue}[C][a] = true</tex>, если пара <tex>(C,a)</tex> содержится в очереди.
Так как при разбиении очередного класса <tex>R</tex> на подклассы <tex>R_1</tex> и <tex>R_2</tex> мы в действительности создаем лишь один новый класс, то замена класса <tex>R</tex> в очереди на подклассы, образовавшиеся при разбиении, сводится лишь к взаимодействию с массивом <tex>\mathtt{InQueue}</tex>. В результате каждая операция с очередью требует <tex>O(1)</tex> времени.

===Время работы===

{{Лемма
|about = 1
|id = Лемма1
|statement =
Количество классов, созданных во время выполнения алгоритма, не превышает <tex>2 |Q| - 1</tex>.
|proof =
Представим дерево, которое соответствует операциям разделения классов на подклассы. Корнем этого дерева является все множество состояний <tex>Q</tex>. Листьями являются классы эквивалентности, оставшиеся после работы алгоритма. Так как дерево бинарное {{---}} каждый класс может породить лишь два новых, а количество листьев не может быть больше <tex>|Q|</tex>, то количество узлов этого дерева не может быть больше <tex>2 |Q| - 1</tex>, что доказывает утверждение леммы.
}}

{{Лемма
|about = 2
|id = Лемма2
|statement =
Количество итераций цикла <tex>while</tex> не превышает <tex> 2 |\Sigma| |Q| </tex>.
|proof =
Для доказательства этого утверждения достаточно показать, что количество пар <tex>(C,a)</tex> добавленных в очередь <tex>S</tex> не превосходит <tex> 2 |\Sigma| |Q| </tex>, так как на каждой итерации мы извлекаем одну пару из очереди.

По [[#Лемма1 | лемме(1)]] количество классов не превосходит <tex>2 |Q| - 1</tex>. Пусть <tex>C</tex> элемент текущего разбиения. Тогда количество пар <tex>(C,a), \ a \in \Sigma</tex> не может быть больше <tex>|\Sigma|</tex>. Отсюда следует, что всего различных пар, которые можно добавить в очередь, не превосходит <tex> 2 |\Sigma| |Q| </tex>.
}}

{{Лемма
|about = 3
|id = Лемма3
|statement =
Пусть <tex>a \in \Sigma</tex> и <tex>p \in Q</tex>. Тогда количество пар <tex>(C,a)</tex>, где <tex>p \in C</tex>, которые мы удалим из очереди, не превосходит <tex>\log_2(|Q|)</tex> для фиксированных <tex>a</tex> и <tex>p</tex>.
|proof =
Рассмотрим пару <tex>(C,a)</tex>, где <tex>p \in C</tex>, которую мы удаляем из очереди. И пусть <tex>(C',a)</tex> следующая пара, где <tex>p \in C'</tex> и которую мы удалим из очереди. Согласно нашему алгоритму класс <tex>C'</tex> мог появиться в очереди только после операции <tex>\mathtt{replace}</tex>. Но после первого же разбиения класса <tex>C</tex> на подклассы мы добавим в очередь пару <tex>(C'', a)</tex>, где <tex>C''</tex> меньший из образовавшихся подклассов, то есть <tex>|C''| \leqslant |C| \ / \ 2</tex>. Так же заметим, что <tex>C' \subseteq C''</tex>, а следовательно <tex>|C'| \leqslant |C| \ / \ 2</tex>. Но тогда таких пар не может быть больше, чем <tex>\log_2(|Q|)</tex>.
}}

{{Лемма
|about = 4
|id = Лемма4
|statement =
<tex>\sum |\mathtt{Inverse}|</tex> по всем итерациям цикла <tex>while</tex> не превосходит <tex>|\Sigma| |Q| \log_2(|Q|)</tex>.
|proof =
Пусть <tex>x, y \in Q</tex>, <tex>a \in \Sigma</tex> и <tex> \delta(x, a) = y</tex>. Зафиксируем эту тройку. Заметим, что количество раз, которое <tex>x</tex> встречается в <tex>\mathtt{Inverse}</tex> при условии, что <tex> \delta(x, a) = y</tex>, совпадает с числом удаленных из очереди пар <tex>(C, a)</tex>, где <tex>y \in C</tex>. Но по [[#Лемма3 | лемме(3)]] эта величина не превосходит <tex>\log_2(|Q|)</tex>. Просуммировав по всем <tex> x \in Q </tex> и по всем <tex> a \in \Sigma</tex> мы получим утверждение леммы.
}}

{{Теорема
|statement =
Время работы алгоритма Хопкрофта равно <tex>O(|\Sigma| |Q| \log(|Q|)</tex>.
|proof =
Оценим, сколько времени занимает каждая часть алгоритма:

*Построение массива <tex>\mathtt{Inv}</tex> занимает <tex>O(|\Sigma| |Q|)</tex> времени.

*По [[#Лемма2 | второй лемме]] количество итераций цикла <tex>while</tex> не превосходит <tex>O(|\Sigma| |Q|)</tex>.

*Операции с множеством <tex>T'</tex> и разбиение классов на подклассы требуют <tex>O(\sum(|\mathtt{Inverse}|))</tex> времени. Но по [[#Лемма4 | лемме(4)]] <tex>\sum(|\mathtt{Inverse}|)</tex> не превосходит <tex>|\Sigma| |Q| \log_2(|Q|)</tex>, то есть данная часть алгоритма выполняется за <tex>O(|\Sigma| |Q| \log_2(|Q|))</tex>.

*В [[#Лемма1 | лемме(1)]] мы показали, что в процессе работы алгоритма не может появится больше, чем <tex>2 |Q| - 1</tex> классов, из чего следует, что количество операций <tex>\mathtt{replace}</tex> равно <tex>O(|\Sigma| |Q|)</tex>.

Итого, получается, что время работы алгоритма Хопкрофта не превышает <tex> O(|\Sigma| |Q|) + O(|\Sigma| |Q|) + O(|\Sigma| |Q| \log_2(|Q|)) + O(|\Sigma| |Q|) = O(|\Sigma| |Q| \log_2(|Q|))</tex>.
}}

== Литература ==
* ''Хопкрофт Д., Мотвани Р., Ульман Д.'' Введение в теорию автоматов, языков и вычислений, 2-е изд. : Пер. с англ. — М.: Издательский дом «Вильямс», 2002. — С. 177 — ISBN 5-8459-0261-4 (рус.)
* ''D. Gries.'' Describing an algorithm by Hopcroft. Technical Report TR-72-151, Cornell University, December 1972.
* ''Hang Zhou.'' Implementation of Hopcroft's Algorithm, 19 December 2009.

[[Категория: Теория формальных языков]]
[[Категория: Автоматы и регулярные языки]]

Алгоритм Левита

2013-11-30T13:20:46Z

194.85.160.130: /* Доказательство */

'''Алгоритм Левита''' (Levit algorithm) находит расстояние от заданной вершины <tex>s</tex> до всех остальных. Позволяет работать с ребрами отрицательного веса при отсутствии отрицательных циклов.

== Алгоритм ==

Пусть <tex>d_i</tex> {{---}} текущая длина кратчайшего пути до вершины <tex>i</tex>. Изначально, все элементы <tex>d</tex>, кроме <tex>s</tex>-го равны бесконечности; <tex>d[s] = 0</tex>.

Разделим вершины на три множества:
* <tex>M_0</tex> {{---}} вершины, расстояние до которых уже вычислено (возможно, не окончательно)
* <tex>M_1</tex> {{---}} вершины, расстояние до которых вычисляется. Это множество в свою очередь делится на два упорядоченных подмножества:
# <tex>M_1^{'}</tex> {{---}} основная очередь
# <tex>M_1^{''}</tex> {{---}} срочная очередь
* <tex>M_2</tex> {{---}} вершины, расстояние до которых еще не вычислено

Изначально все вершины, кроме <tex>s</tex> помещаются в множество <tex>M_2</tex>. Вершина <tex>s</tex> помещается в множество <tex>M_1</tex> (в любую из очередей).

'''Шаг алгоритма:''' выбирается вершина <tex>u</tex> из <tex>M_1</tex>. Если очередь <tex>M_1^{''}</tex> не пуста, то вершина берется из нее, иначе из <tex>M_1^{'}</tex>. Далее, для каждого ребра <tex>uv \in E</tex>:
* если <tex>v \in M_2</tex>, то <tex>v</tex> переводится в конец очереди <tex>M_1^{'}</tex>. При этом <tex>d_v \gets d_u + w_{uv}</tex> (производится релаксация ребра <tex>uv</tex>)
* если <tex>v \in M_1</tex>, то происходит релаксация ребра <tex>uv</tex>
* если <tex>v \in M_0</tex> и <tex>d_v > d_u + w_{uv}</tex>, то происходит релаксация ребра <tex>uv</tex> и <tex>v</tex> помещается в <tex>M_1^{''}</tex>
В конце шага помещаем вершину <tex>u</tex> в множество <tex>M_0</tex>.

Алгоритм заканчивает работу, когда множество <tex>M_1</tex> становится пустым.

== Псевдокод ==

'''for''' u <tex>\in</tex> V ''':'''
<tex>d_v \gets</tex> <tex>\infty</tex>
<tex>d_s \gets 0</tex>

<tex>M_1^{''}</tex>.add(s)
'''for''' u <tex>\neq</tex> s <tex>\in</tex> V ''':'''
<tex>M_2</tex>.add(u)

'''while''' <tex>M_1^{'} \neq \varnothing</tex> '''and''' <tex>M_1^{''} \neq \varnothing</tex> ''':'''
'''if''' <tex>M_1^{''} \neq \varnothing</tex> ''':'''
u <tex>\gets</tex> <tex>M_1^{''}</tex>.pop()
'''else :'''
u <tex>\gets</tex> <tex>M_1{'}</tex>.pop()

'''for''' uv <tex>\in</tex> E ''':'''
'''if''' v <tex>\in M_2</tex> ''':'''
<tex>M_1^{'}</tex>.push(v)
relax(uv, d)
'''if''' v <tex>\in M_1</tex> ''':'''
relax(uv, d)
'''if''' v <tex>\in M_0</tex> '''and''' <tex>d_v > d_u + w_{uv}</tex> ''':'''
<tex>M_1^{''}</tex>.push(v)
relax(uv, d)

<tex>M_0</tex>.add(u)

== Доказательство ==

{{Лемма
|statement= Алгоритм отработает за конечное время
|proof= Не теряя общности, будем считать, что граф связен. Тогда в конце работы алгоритма все вершины окажутся в <tex>M_0</tex>. PROFIT!!
}}

== Сложность ==

== Источники ==
* [http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9B%D0%B5%D0%B2%D0%B8%D1%82%D0%B0 Алгоритм Левита - Википедия, свободная энциклопедия]
* [http://e-maxx.ru/algo/levit_algorithm Алгоритм Левита - MAXimal::algo]
* И. В. Романовский, Дискретный анализ, ISBN 5-7940-0138-0; 2008 г., стр. 228-234.

Алгоритм Левита

2013-11-30T08:50:55Z

194.85.160.130: /* См. также */

'''Алгоритм Левита''' (Levit algorithm) находит расстояние от заданной вершины <tex>s</tex> до всех остальных. Позволяет работать с ребрами отрицательного веса при отсутствии отрицательных циклов.

== Алгоритм ==

Пусть <tex>d_i</tex> {{---}} текущая длина кратчайшего пути до вершины <tex>i</tex>. Изначально, все элементы <tex>d</tex>, кроме <tex>s</tex>-го равны бесконечности; <tex>d[s] = 0</tex>.

Разделим вершины на три множества:
* <tex>M_0</tex> {{---}} вершины, расстояние до которых уже вычислено (возможно, не окончательно)
* <tex>M_1</tex> {{---}} вершины, расстояние до которых вычисляется. Это множество в свою очередь делится на два упорядоченных подмножества:
# <tex>M_1^{'}</tex> {{---}} основная очередь
# <tex>M_1^{''}</tex> {{---}} срочная очередь
* <tex>M_2</tex> {{---}} вершины, расстояние до которых еще не вычислено

Изначально все вершины, кроме <tex>s</tex> помещаются в множество <tex>M_2</tex>. Вершина <tex>s</tex> помещается в множество <tex>M_1</tex> (в любую из очередей).

'''Шаг алгоритма:''' выбирается вершина <tex>u</tex> из <tex>M_1</tex>. Если очередь <tex>M_1^{''}</tex> не пуста, то вершина берется из нее, иначе из <tex>M_1^{'}</tex>. Далее, для каждого ребра <tex>uv \in E</tex>:
* если <tex>v \in M_2</tex>, то <tex>v</tex> переводится в конец очереди <tex>M_1^{'}</tex>. При этом <tex>d_v \gets d_u + w_{uv}</tex> (производится релаксация ребра <tex>uv</tex>)
* если <tex>v \in M_1</tex>, то происходит релаксация ребра <tex>uv</tex>
* если <tex>v \in M_0</tex> и <tex>d_v > d_u + w_{uv}</tex>, то происходит релаксация ребра <tex>uv</tex> и <tex>v</tex> помещается в <tex>M_1^{''}</tex>
В конце шага помещаем вершину <tex>u</tex> в множество <tex>M_0</tex>.

Алгоритм заканчивает работу, когда множество <tex>M_1</tex> становится пустым.

== Псевдокод ==

'''for''' u <tex>\in</tex> V ''':'''
<tex>d_v \gets</tex> <tex>\infty</tex>
<tex>d_s \gets 0</tex>

<tex>M_1^{''}</tex>.add(s)
'''for''' u <tex>\neq</tex> s <tex>\in</tex> V ''':'''
<tex>M_2</tex>.add(u)

'''while''' <tex>M_1^{'} \neq \varnothing</tex> '''and''' <tex>M_1^{''} \neq \varnothing</tex> ''':'''
'''if''' <tex>M_1^{''} \neq \varnothing</tex> ''':'''
u <tex>\gets</tex> <tex>M_1^{''}</tex>.pop()
'''else :'''
u <tex>\gets</tex> <tex>M_1{'}</tex>.pop()

'''for''' uv <tex>\in</tex> E ''':'''
'''if''' v <tex>\in M_2</tex> ''':'''
<tex>M_1^{'}</tex>.push(v)
relax(uv, d)
'''if''' v <tex>\in M_1</tex> ''':'''
relax(uv, d)
'''if''' v <tex>\in M_0</tex> '''and''' <tex>d_v > d_u + w_{uv}</tex> ''':'''
<tex>M_1^{''}</tex>.push(v)
relax(uv, d)

<tex>M_0</tex>.add(u)

== Доказательство ==

== Сложность ==

== Источники ==
* [http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9B%D0%B5%D0%B2%D0%B8%D1%82%D0%B0 Алгоритм Левита - Википедия, свободная энциклопедия]
* [http://e-maxx.ru/algo/levit_algorithm Алгоритм Левита - MAXimal::algo]
* И. В. Романовский, Дискретный анализ, ISBN 5-7940-0138-0; 2008 г., стр. 228-234.

Алгоритм Левита

2013-11-30T08:50:41Z

194.85.160.130:

'''Алгоритм Левита''' (Levit algorithm) находит расстояние от заданной вершины <tex>s</tex> до всех остальных. Позволяет работать с ребрами отрицательного веса при отсутствии отрицательных циклов.

== Алгоритм ==

Пусть <tex>d_i</tex> {{---}} текущая длина кратчайшего пути до вершины <tex>i</tex>. Изначально, все элементы <tex>d</tex>, кроме <tex>s</tex>-го равны бесконечности; <tex>d[s] = 0</tex>.

Разделим вершины на три множества:
* <tex>M_0</tex> {{---}} вершины, расстояние до которых уже вычислено (возможно, не окончательно)
* <tex>M_1</tex> {{---}} вершины, расстояние до которых вычисляется. Это множество в свою очередь делится на два упорядоченных подмножества:
# <tex>M_1^{'}</tex> {{---}} основная очередь
# <tex>M_1^{''}</tex> {{---}} срочная очередь
* <tex>M_2</tex> {{---}} вершины, расстояние до которых еще не вычислено

Изначально все вершины, кроме <tex>s</tex> помещаются в множество <tex>M_2</tex>. Вершина <tex>s</tex> помещается в множество <tex>M_1</tex> (в любую из очередей).

'''Шаг алгоритма:''' выбирается вершина <tex>u</tex> из <tex>M_1</tex>. Если очередь <tex>M_1^{''}</tex> не пуста, то вершина берется из нее, иначе из <tex>M_1^{'}</tex>. Далее, для каждого ребра <tex>uv \in E</tex>:
* если <tex>v \in M_2</tex>, то <tex>v</tex> переводится в конец очереди <tex>M_1^{'}</tex>. При этом <tex>d_v \gets d_u + w_{uv}</tex> (производится релаксация ребра <tex>uv</tex>)
* если <tex>v \in M_1</tex>, то происходит релаксация ребра <tex>uv</tex>
* если <tex>v \in M_0</tex> и <tex>d_v > d_u + w_{uv}</tex>, то происходит релаксация ребра <tex>uv</tex> и <tex>v</tex> помещается в <tex>M_1^{''}</tex>
В конце шага помещаем вершину <tex>u</tex> в множество <tex>M_0</tex>.

Алгоритм заканчивает работу, когда множество <tex>M_1</tex> становится пустым.

== Псевдокод ==

'''for''' u <tex>\in</tex> V ''':'''
<tex>d_v \gets</tex> <tex>\infty</tex>
<tex>d_s \gets 0</tex>

<tex>M_1^{''}</tex>.add(s)
'''for''' u <tex>\neq</tex> s <tex>\in</tex> V ''':'''
<tex>M_2</tex>.add(u)

'''while''' <tex>M_1^{'} \neq \varnothing</tex> '''and''' <tex>M_1^{''} \neq \varnothing</tex> ''':'''
'''if''' <tex>M_1^{''} \neq \varnothing</tex> ''':'''
u <tex>\gets</tex> <tex>M_1^{''}</tex>.pop()
'''else :'''
u <tex>\gets</tex> <tex>M_1{'}</tex>.pop()

'''for''' uv <tex>\in</tex> E ''':'''
'''if''' v <tex>\in M_2</tex> ''':'''
<tex>M_1^{'}</tex>.push(v)
relax(uv, d)
'''if''' v <tex>\in M_1</tex> ''':'''
relax(uv, d)
'''if''' v <tex>\in M_0</tex> '''and''' <tex>d_v > d_u + w_{uv}</tex> ''':'''
<tex>M_1^{''}</tex>.push(v)
relax(uv, d)

<tex>M_0</tex>.add(u)

== Доказательство ==

== Сложность ==

== См. также ==

* [[Алгоритм A*]]
* [[Алгоритм Дейкстры]]
* [[Алгоритм Джонсона]]
* [[Алгоритм Флойда]]
* [[Алгоритм Форда-Беллмана]]

== Источники ==
* [http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9B%D0%B5%D0%B2%D0%B8%D1%82%D0%B0 Алгоритм Левита - Википедия, свободная энциклопедия]
* [http://e-maxx.ru/algo/levit_algorithm Алгоритм Левита - MAXimal::algo]
* И. В. Романовский, Дискретный анализ, ISBN 5-7940-0138-0; 2008 г., стр. 228-234.

Алгоритм Левита

2013-11-30T08:50:16Z

194.85.160.130: /* Сложность */

'''Алгоритм Левита''' (Levit algorithm) находит расстояние от заданной вершины <tex>s</tex> до всех остальных. Позволяет работать с ребрами отрицательного веса при отсутствии отрицательных циклов.

== Алгоритм ==

Пусть <tex>d_i</tex> {{---}} текущая длина кратчайшего пути до вершины <tex>i</tex>. Изначально, все элементы <tex>d</tex>, кроме <tex>s</tex>-го равны бесконечности; <tex>d[s] = 0</tex>.

Разделим вершины на три множества:
* <tex>M_0</tex> {{---}} вершины, расстояние до которых уже вычислено (возможно, не окончательно)
* <tex>M_1</tex> {{---}} вершины, расстояние до которых вычисляется. Это множество в свою очередь делится на два упорядоченных подмножества:
# <tex>M_1^{'}</tex> {{---}} основная очередь
# <tex>M_1^{''}</tex> {{---}} срочная очередь
* <tex>M_2</tex> {{---}} вершины, расстояние до которых еще не вычислено

Изначально все вершины, кроме <tex>s</tex> помещаются в множество <tex>M_2</tex>. Вершина <tex>s</tex> помещается в множество <tex>M_1</tex> (в любую из очередей).

'''Шаг алгоритма:''' выбирается вершина <tex>u</tex> из <tex>M_1</tex>. Если очередь <tex>M_1^{''}</tex> не пуста, то вершина берется из нее, иначе из <tex>M_1^{'}</tex>. Далее, для каждого ребра <tex>uv \in E</tex>:
* если <tex>v \in M_2</tex>, то <tex>v</tex> переводится в конец очереди <tex>M_1^{'}</tex>. При этом <tex>d_v \gets d_u + w_{uv}</tex> (производится релаксация ребра <tex>uv</tex>)
* если <tex>v \in M_1</tex>, то происходит релаксация ребра <tex>uv</tex>
* если <tex>v \in M_0</tex> и <tex>d_v > d_u + w_{uv}</tex>, то происходит релаксация ребра <tex>uv</tex> и <tex>v</tex> помещается в <tex>M_1^{''}</tex>
В конце шага помещаем вершину <tex>u</tex> в множество <tex>M_0</tex>.

Алгоритм заканчивает работу, когда множество <tex>M_1</tex> становится пустым.

== Псевдокод ==

'''for''' u <tex>\in</tex> V ''':'''
<tex>d_v \gets</tex> <tex>\infty</tex>
<tex>d_s \gets 0</tex>

<tex>M_1^{''}</tex>.add(s)
'''for''' u <tex>\neq</tex> s <tex>\in</tex> V ''':'''
<tex>M_2</tex>.add(u)

'''while''' <tex>M_1^{'} \neq \varnothing</tex> '''and''' <tex>M_1^{''} \neq \varnothing</tex> ''':'''
'''if''' <tex>M_1^{''} \neq \varnothing</tex> ''':'''
u <tex>\gets</tex> <tex>M_1^{''}</tex>.pop()
'''else :'''
u <tex>\gets</tex> <tex>M_1{'}</tex>.pop()

'''for''' uv <tex>\in</tex> E ''':'''
'''if''' v <tex>\in M_2</tex> ''':'''
<tex>M_1^{'}</tex>.push(v)
relax(uv, d)
'''if''' v <tex>\in M_1</tex> ''':'''
relax(uv, d)
'''if''' v <tex>\in M_0</tex> '''and''' <tex>d_v > d_u + w_{uv}</tex> ''':'''
<tex>M_1^{''}</tex>.push(v)
relax(uv, d)

<tex>M_0</tex>.add(u)

== Сложность ==

== См. также ==

* [[Алгоритм A*]]
* [[Алгоритм Дейкстры]]
* [[Алгоритм Джонсона]]
* [[Алгоритм Флойда]]
* [[Алгоритм Форда-Беллмана]]

== Источники ==
* [http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9B%D0%B5%D0%B2%D0%B8%D1%82%D0%B0 Алгоритм Левита - Википедия, свободная энциклопедия]
* [http://e-maxx.ru/algo/levit_algorithm Алгоритм Левита - MAXimal::algo]
* И. В. Романовский, Дискретный анализ, ISBN 5-7940-0138-0; 2008 г., стр. 228-234.

Алгоритм Левита

2013-11-30T08:44:33Z

194.85.160.130: /* Псевдокод */

'''Алгоритм Левита''' (Levit algorithm) находит расстояние от заданной вершины <tex>s</tex> до всех остальных. Позволяет работать с ребрами отрицательного веса при отсутствии отрицательных циклов.

== Алгоритм ==

Пусть <tex>d_i</tex> {{---}} текущая длина кратчайшего пути до вершины <tex>i</tex>. Изначально, все элементы <tex>d</tex>, кроме <tex>s</tex>-го равны бесконечности; <tex>d[s] = 0</tex>.

Разделим вершины на три множества:
* <tex>M_0</tex> {{---}} вершины, расстояние до которых уже вычислено (возможно, не окончательно)
* <tex>M_1</tex> {{---}} вершины, расстояние до которых вычисляется. Это множество в свою очередь делится на два упорядоченных подмножества:
# <tex>M_1^{'}</tex> {{---}} основная очередь
# <tex>M_1^{''}</tex> {{---}} срочная очередь
* <tex>M_2</tex> {{---}} вершины, расстояние до которых еще не вычислено

Изначально все вершины, кроме <tex>s</tex> помещаются в множество <tex>M_2</tex>. Вершина <tex>s</tex> помещается в множество <tex>M_1</tex> (в любую из очередей).

'''Шаг алгоритма:''' выбирается вершина <tex>u</tex> из <tex>M_1</tex>. Если очередь <tex>M_1^{''}</tex> не пуста, то вершина берется из нее, иначе из <tex>M_1^{'}</tex>. Далее, для каждого ребра <tex>uv \in E</tex>:
* если <tex>v \in M_2</tex>, то <tex>v</tex> переводится в конец очереди <tex>M_1^{'}</tex>. При этом <tex>d_v \gets d_u + w_{uv}</tex> (производится релаксация ребра <tex>uv</tex>)
* если <tex>v \in M_1</tex>, то происходит релаксация ребра <tex>uv</tex>
* если <tex>v \in M_0</tex> и <tex>d_v > d_u + w_{uv}</tex>, то происходит релаксация ребра <tex>uv</tex> и <tex>v</tex> помещается в <tex>M_1^{''}</tex>
В конце шага помещаем вершину <tex>u</tex> в множество <tex>M_0</tex>.

Алгоритм заканчивает работу, когда множество <tex>M_1</tex> становится пустым.

== Псевдокод ==

'''for''' u <tex>\in</tex> V ''':'''
<tex>d_v \gets</tex> <tex>\infty</tex>
<tex>d_s \gets 0</tex>

<tex>M_1^{''}</tex>.add(s)
'''for''' u <tex>\neq</tex> s <tex>\in</tex> V ''':'''
<tex>M_2</tex>.add(u)

'''while''' <tex>M_1^{'} \neq \varnothing</tex> '''and''' <tex>M_1^{''} \neq \varnothing</tex> ''':'''
'''if''' <tex>M_1^{''} \neq \varnothing</tex> ''':'''
u <tex>\gets</tex> <tex>M_1^{''}</tex>.pop()
'''else :'''
u <tex>\gets</tex> <tex>M_1{'}</tex>.pop()

'''for''' uv <tex>\in</tex> E ''':'''
'''if''' v <tex>\in M_2</tex> ''':'''
<tex>M_1^{'}</tex>.push(v)
relax(uv, d)
'''if''' v <tex>\in M_1</tex> ''':'''
relax(uv, d)
'''if''' v <tex>\in M_0</tex> '''and''' <tex>d_v > d_u + w_{uv}</tex> ''':'''
<tex>M_1^{''}</tex>.push(v)
relax(uv, d)

<tex>M_0</tex>.add(u)

== Сложность ==

В худшем случае алгоритм Левита работает за <tex>\bf O(|V| \cdot 2^{|V|})</tex>. Это происходит вследствие того, что некоторые вершины приходится обрабатывать повторно. Однако эксперементы показывают, что для реальных графов(например, карт дорог) данный алгоритм оказывается достаточно быстрым и '''эксперементальная''' оценка данного алгоритма составляет <tex>\bf O(|E| \cdot log |V|)</tex>.

== См. также ==

* [[Алгоритм A*]]
* [[Алгоритм Дейкстры]]
* [[Алгоритм Джонсона]]
* [[Алгоритм Флойда]]
* [[Алгоритм Форда-Беллмана]]

== Источники ==
* [http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9B%D0%B5%D0%B2%D0%B8%D1%82%D0%B0 Алгоритм Левита - Википедия, свободная энциклопедия]
* [http://e-maxx.ru/algo/levit_algorithm Алгоритм Левита - MAXimal::algo]
* И. В. Романовский, Дискретный анализ, ISBN 5-7940-0138-0; 2008 г., стр. 228-234.

Алгоритм Левита

2013-11-30T08:39:33Z

194.85.160.130: /* Алгоритм */

'''Алгоритм Левита''' (Levit algorithm) находит расстояние от заданной вершины <tex>s</tex> до всех остальных. Позволяет работать с ребрами отрицательного веса при отсутствии отрицательных циклов.

== Алгоритм ==

Пусть <tex>d_i</tex> {{---}} текущая длина кратчайшего пути до вершины <tex>i</tex>. Изначально, все элементы <tex>d</tex>, кроме <tex>s</tex>-го равны бесконечности; <tex>d[s] = 0</tex>.

Разделим вершины на три множества:
* <tex>M_0</tex> {{---}} вершины, расстояние до которых уже вычислено (возможно, не окончательно)
* <tex>M_1</tex> {{---}} вершины, расстояние до которых вычисляется. Это множество в свою очередь делится на два упорядоченных подмножества:
# <tex>M_1^{'}</tex> {{---}} основная очередь
# <tex>M_1^{''}</tex> {{---}} срочная очередь
* <tex>M_2</tex> {{---}} вершины, расстояние до которых еще не вычислено

Изначально все вершины, кроме <tex>s</tex> помещаются в множество <tex>M_2</tex>. Вершина <tex>s</tex> помещается в множество <tex>M_1</tex> (в любую из очередей).

'''Шаг алгоритма:''' выбирается вершина <tex>u</tex> из <tex>M_1</tex>. Если очередь <tex>M_1^{''}</tex> не пуста, то вершина берется из нее, иначе из <tex>M_1^{'}</tex>. Далее, для каждого ребра <tex>uv \in E</tex>:
* если <tex>v \in M_2</tex>, то <tex>v</tex> переводится в конец очереди <tex>M_1^{'}</tex>. При этом <tex>d_v \gets d_u + w_{uv}</tex> (производится релаксация ребра <tex>uv</tex>)
* если <tex>v \in M_1</tex>, то происходит релаксация ребра <tex>uv</tex>
* если <tex>v \in M_0</tex> и <tex>d_v > d_u + w_{uv}</tex>, то происходит релаксация ребра <tex>uv</tex> и <tex>v</tex> помещается в <tex>M_1^{''}</tex>
В конце шага помещаем вершину <tex>u</tex> в множество <tex>M_0</tex>.

Алгоритм заканчивает работу, когда множество <tex>M_1</tex> становится пустым.

== Псевдокод ==

'''for''' u <tex>\in</tex> V ''':'''
<tex>d_v \gets</tex> <tex>\infty</tex>
<tex>d_s \gets 0</tex>

<tex>M_1^{''}</tex>.add(s)
'''for''' u <tex>\neq</tex> s <tex>\in</tex> V ''':'''
<tex>M_2</tex>.add(u)

'''while''' <tex>M_1 \neq \varnothing</tex> ''':'''
'''if''' <tex>M_1^{''} \neq \varnothing</tex> ''':'''
u <tex>\gets</tex> <tex>M_1^{''}</tex>.pop()
'''else :'''
u <tex>\gets</tex> <tex>M_1{'}</tex>.pop()

'''for''' uv <tex>\in</tex> E ''':'''
'''if''' v <tex>\in M_2</tex> ''':'''
<tex>M_1^{'}</tex>.push(v)
relax(uv)
'''if''' v <tex>\in M_1</tex> ''':'''
relax(uv)
'''if''' v <tex>\in M_0</tex> '''and''' <tex>d_v > d_u + w_{uv}</tex> ''':'''
<tex>M_1^{''}</tex>.push(v)
relax(uv)

<tex>M_0</tex>.add(u)

== Сложность ==

В худшем случае алгоритм Левита работает за <tex>\bf O(|V| \cdot 2^{|V|})</tex>. Это происходит вследствие того, что некоторые вершины приходится обрабатывать повторно. Однако эксперементы показывают, что для реальных графов(например, карт дорог) данный алгоритм оказывается достаточно быстрым и '''эксперементальная''' оценка данного алгоритма составляет <tex>\bf O(|E| \cdot log |V|)</tex>.

== См. также ==

* [[Алгоритм A*]]
* [[Алгоритм Дейкстры]]
* [[Алгоритм Джонсона]]
* [[Алгоритм Флойда]]
* [[Алгоритм Форда-Беллмана]]

== Источники ==
* [http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9B%D0%B5%D0%B2%D0%B8%D1%82%D0%B0 Алгоритм Левита - Википедия, свободная энциклопедия]
* [http://e-maxx.ru/algo/levit_algorithm Алгоритм Левита - MAXimal::algo]
* И. В. Романовский, Дискретный анализ, ISBN 5-7940-0138-0; 2008 г., стр. 228-234.

Лямбда-исчисление

2012-12-06T17:41:54Z

194.85.160.130: /* Логические значения */

{{В разработке}}

== Лямбда-исчисление==

''Лямбда-исчисление'' {{---}} формальная система, придуманная в 1930-х годах
Алонзо Чёрчем. Лямбда-функция является, по сути, анонимной функцией.
Эта концепция показала себя удобной и сейчас активно используется во многих
языках программирования.

Более формально, ''лямбда-функцию'' (или, ''лямбда-терм'') можно задать
следующей грамматикой:
{{Определение
|definition=
<tex>
\begin{array}{r c l}
\langle Term \rangle & ::= & \langle Variable \rangle \\
& || & \langle Term \rangle \langle Term \rangle \\
& || & \lambda \langle Variable \rangle \to \langle Term \rangle\\
& || & ( \langle Term \rangle )\\
\langle Variable \rangle & ::= & \langle Char \rangle *\\
\end{array}
</tex>
}}

В первом случае функция является просто переменной.
Во втором происходит ''аппликация'' (''применение'') одной функции к другой.
Это аналогично вычислению функции-левого операнда на аргументе-правом операнде.
В третьем {{---}} ''абстракция'' по переменной. В данном случае происходит
создание функции одного аргумента с заданными именем аргумента и телом функции.

Рассмотрим, например, функцию <tex>id = \lambda x \to x</tex>. Эта функция принимает аргумент и
возвращает его неизменённым. Например,
<tex>id 2 \equiv 2</tex>. Аналогично, <tex>id y == y</tex>.

Ещё один пример функции: <tex>sum = \lambda x \to \lambda y \to x + y|. Эта функция двух аргументов,
которая возвращает их сумму. Правда, здесь мы немного вышли за написанную выше грамматику.
Ну да ладно. <tex>sum 2 3 == 5</tex>

===Приоритет операций===
* Применение левоассоциативно: <tex>x y z w == ((x y) z) w</tex>
* Аппликация забирает себе всё, до чего дотянется: <tex>\lambda x \to \lambda y \to \lambda z \to z y x \equiv \lambda x \to (\lambda y \to (\lambda z \to ((z y) x)))</tex>
* Скобки играют привычную роль группировки действий

===Свободные и связанные переменные===
''Связанными'' переменными называются все переменные, по которым выше в
дереве разбора были абстракции. Все остальные переменные называются свободными.

Например, в <tex>\lambda x \to \lambda y \to x</tex>, <tex>x</tex> связана, а <tex>y</tex>{{---}} свободна. А в <tex>\lambda y \to x (\lambda x \to x)</tex>
в своём первом вхождении переменная <tex>x</tex> свободна, а во втором {{---}} связана.

Рассмотрим функции <tex>\lambda y \to y</tex> и <tex>\lambda x \to y</tex>. В первой из них при взгляде на <tex>y</tex>
понятно, что она имеет отношение к переменной, по которой производилась
абстракция. Если по одной и той же
переменной абстракция производилась более одного раза, то переменная связана
с самым поздним (самым нижним в дереве разбора) абстрагированием. Например, в
<tex>\lambda x \to \lambda x \to \lambda y \to \lambda x \to x</tex>, переменная <tex>x</tex> связана с самой правой абстракцией
по <tex>x</tex>.

===<tex>\alpha</tex>-конверсия===

Рассмотрим функции <tex>(\lambda x \to x) z</tex> и <tex>(\lambda y \to y) z</tex>. Интуитивно понятно, что они
являются одинаковыми.

{{Определение
|definition=''<tex>\alpha</tex>-конверсия'' {{---}} переименование связанной переменной. Выражение
<tex>\lambda x \to f</tex> можно заменить на <tex>\lambda y \to f[x := y]</tex>, если <tex>y</tex> не входит свободно в <tex>f</tex>,
где <tex>f[x:=y]</tex> означает замену всех свободных вхождений <tex>x</tex> в <tex>f</tex> на <tex>y</tex>.
}}

Функции, получающиеся одна из другой с помощью <tex>\alpha</tex>-конверсий, называются
''<tex>\alpha</tex>-эквивалентными'' и обозначаются <tex>f \equiv_\alpha g</tex>.

Функции <tex>\lambda x \to \lambda y \to x y z</tex> и <tex>\lambda a \to \lambda x \to a x z</tex> являются <tex>\alpha</tex>-эквивалентными,
а <tex>\lambda x \to \lambda y \to y z</tex> и <tex>\lambda y \to \lambda x \to y z</tex> {{---}} нет.

===<tex>\beta</tex>-редукция===

{{Определение
|definition=
<tex>\beta</tex>-редукция олицетворяет идею счёта значения функции. Выражение вида
<tex>(\lambda x \to f) y</tex> можно заменить на <tex>f[x := y]</tex>, где <tex>f[x:=y]</tex>, как и ранее, означает
замену всех свободных вхождений <tex>x</tex> в <tex>f</tex> на <tex>y</tex>.
}}

{{Определение
|definition=
Через <tex>f \to_\beta g</tex> обозначают сведение <tex>f</tex> к <tex>g</tex> с помощью одной <tex>\beta</tex>-редукции.
А через <tex>f \to_\beta^* g</tex> {{---}} за ноль или более.
}}

===<tex>\eta</tex>-редукция===
Рассмотрим выражение вида <tex>\lambda x \to f x</tex>. Если подставить в эту функцию значение
<tex>y</tex>, то получим: <tex>(\lambda x \to f x) y \to_\beta f y</tex>. Но если просто подставить
<tex>y</tex> в <tex>f</tex>, то получится то же самое.

{{Определение
|definition=
<tex>\eta</tex>-редукция {{---}} преобразование <tex>\lambda x \to f x</tex> в <tex>f</tex>.
}}

==Нотация Де Брюина==
Существует также альтернативное эквивалентное определение <tex>\lambda</tex>-исчисления.
В оригинальном определении для обозначения переменных использовались имена,
и была проблема с тем, что не были запрещены одинаковые имена в разных
абстракциях.

От этой проблемы можно избавиться следующим образом. Вместо имени переменной
будет храниться натуральное число {{---}} количество абстракций в дереве разбора,
на которое нужно подняться, чтобы найти ту лямбду, с которой данная переменная
связана. В данной нотации получаются несколько более простые определения
свободных переменных и <tex>\beta</tex>-редукции.

Переменная называется свободной, если ей соответствует число, которое больше
количества абстракций на пути до неё в дереве разбора.

При <tex>\beta</tex>-редукции же нужно будет ко всем свободным переменным заменяющего
дерева при каждой замене прибавить число, равное разницы уровней раньше и сейчас.
Это будет соответствовать тому, что эта переменная продолжит <<держаться>> за
ту же лямбду, что и раньше.

==Нумералы Чёрча и программирование на <tex>\lambda</tex>-исчислении==

===Определение===
Введём на основе лямбда-исчисления аналог натуральных чисел, основанный на идее,
что натуральное число {{---}} это или ноль, или увеличенное на единицу натуральное
число.

* <tex>\bar 0 = \lambda s \to \lambda z \to z</tex>
* <tex>\bar 1 = \lambda s \to \lambda z \to s z</tex>
* <tex>\bar 2 = \lambda s \to \lambda z \to s (s z)</tex>
* <tex>\bar 3 = \lambda s \to \lambda z \to s (s (s z))</tex>

Каждое число будет функцией двух аргументов: какой-то функции и начального значения.
Число <tex>n</tex> будет <tex>n</tex> раз применять функцию к начальному значению и возвращать
результат. Если такому <<числу>> дать на вход функцию <tex>(+1)</tex> и <tex>0</tex> в качестве
начального значения, то на выходе как раз будет ожидаемое от функции число:
<tex>\bar 3 (+1) 0 \equiv 3</tex>.

===+1===
Функция, прибавляющая 1 к числу, должна принимать первым аргументом число.
Но число {{---}} функция двух аргументов. Значит, эта функция должна принимать три
аргумента: <<число>> <tex>n</tex>, которое хочется увеличить, функция, которую надо будет
<tex>n+1</tex> раз применить, и начальное значение.

<tex>\operatorname{succ} = \lambda n \to \lambda s \to \lambda z \to s (n s z)</tex>

Здесь <tex>n s z</tex> {{---}} <tex>n</tex> раз применённая к <tex>z</tex> функция <tex>s</tex>. Но нужно применить <tex>n+1</tex>
раз. Отсюда <tex>s (n s z)</tex>.

===Сложение===
Сложение двух чисел похоже на прибавление единицы. Но только надо прибавить не единицу, а второе число.

<tex>\operatorname{plus} = \lambda n \to \lambda m \to \lambda s \to \lambda z \to n s (m s z)</tex>

<tex>n</tex> раз применить <tex>s</tex> к применённому <tex>m</tex> раз <tex>s</tex> к <tex>z</tex>

<tex>(\operatorname{plus} \bar 3 \bar 3) (+1) 0 \equiv 6</tex>

===Умножение===
Умножение похоже на сложение, но прибавлять надо не единицу, а второе число.
Или, в терминах нумералов Чёрча, в качестве применяемой несколько раз
функции должна быть не <tex>s</tex>, а функция, применяющая <tex>n</tex> раз <tex>s</tex>.

<tex>\operatorname{mult} = \lambda n \to \lambda m \to \lambda s \to n (m s)</tex>

Здесь <tex>m s</tex> {{---}} функция, которая <tex>m</tex> раз применит <tex>s</tex> к тому, что дадут ей на
вход. С помощью <tex>\eta</tex>-редукции можно немного сократить эту формулу

<tex>\operatorname{mult} = \lambda n \to \lambda m \to \lambda s \to n (m s)</tex>

<tex>(\operatorname{mult} \bar 3 \bar 3) (+1) 0 \equiv 9</tex>

===Возведение в степень===
It's a kind of magic

<tex>\operatorname{power} = \lambda n \to \lambda m \to m n</tex>

<tex>(\operatorname{power} \bar 3 (\operatorname{succ} \bar 3)) (+1) 0 \equiv 81</tex>

===Логические значения===
<tex>\operatorname{true} = \lambda a \to \lambda b \to a</tex>

<tex>\operatorname{false} = \lambda a \to \lambda b \to b</tex>

Функции двух аргументов, возвращающие первый и второй, соответственное, аргументы.
Забавный факт: <tex>\operatorname{false} \equiv_\alpha \operatorname{zero}</tex>. Эти функции сделаны такими для того,
чтобы красиво написать функцию <tex>\operatorname{if}</tex>:

<tex>\operatorname{if} = \lambda p \to \lambda t \to \lambda e \to p\ t\ e</tex>

Если ей в качестве первого аргумента дадут <tex>\operatorname{true}</tex>, то вернётся <tex>t</tex>, иначе {{---}} <tex>e</tex>.

Стандартные функции булевой логики:

<tex>\operatorname{and} = \lambda n \to \lambda m \to \operatorname{if} n\ m\ \operatorname{false}</tex>

<tex>\operatorname{or} = \lambda n \to \lambda m \to \operatorname{if} n\ \operatorname{true} m</tex>

<tex>\operatorname{not} = \lambda b \to \operatorname{if} b\ \operatorname{false} \operatorname{true}</tex>

Ещё одной важной функцией является функция проверки, является ли число нулём:

<tex>\operatorname{isZero} = \lambda n \to n\ (\lambda c \to \operatorname{false})\ \operatorname{true}</tex>

Функция выглядит несколько странно. <tex>\lambda c -> \operatorname{false}</tex> {{---}} функция, которая независимо
от того, что ей дали на вход, возвращает <tex>\operatorname{false}</tex>. Тогда, если в качестве <tex>n</tex>
будет дан ноль, то функция, по определению нуля, не выполнится ни разу, и будет
возвращено значение по умолчанию <tex>\operatorname{true}</tex>. Иначе же функция будет запущено, и
вернётся <tex>\operatorname{false}</tex>.

===Пара===

<tex>\operatorname{pair} = \lambda a \to \lambda b \to \lambda t \to t\ a\ b</tex>

<tex>\operatorname{fst} = \lambda p \to p\ \operatorname{true}</tex>

<tex>\operatorname{snd} = \lambda p \to p\ \operatorname{false}</tex>

Функция <tex>\operatorname{pair}</tex> принимает два значения и запаковывает их в пару так, чтобы к ним можно было обращаться по <tex>\operatorname{fst}</tex> и <tex>\operatorname{snd}</tex>. В <tex>\operatorname{fst}</tex> и <tex>\operatorname{snd}</tex> вместо <tex>t</tex> в <tex>\operatorname{pair}</tex> будет подставлено <tex>\operatorname{true}</tex> или <tex>\operatorname{false}</tex>, возвращающие, соответственно, первый и второй аргументы, то есть <tex>a</tex> или <tex>b</tex>, соответственно.

===Вычитание===
В отличие от всех предыдущих функций, вычитание для натуральных чисел определено только в случае, если уменьшаемое больше вычитаемого. Положим в противном случае результат равным нулю. Пусть уже есть функция, которая вычитает из числа единицу. Тогда на её основе легко сделать, собственно, вычитание.

<tex>\operatorname{minus} = \lambda n \to \lambda m \to m\ \operatorname{pred} n</tex>

Это то же самое, что <tex>m</tex> раз вычесть единицу из <tex>n</tex>.

Осталось, собственно, функция для вычитания единицы. Однако, это не так просто, как может показаться на первый взгляд. Проблема в том, что, имея функцию, которую нужно применить для того, чтобы продвинуться вперёд, продвинуться назад будет проблематично. Если попробовать воспользоваться идеей о том, чтобы, начав от нуля, идти вперёд, и пройти на один шаг меньше, то будет не очень понятно, как же остановиться ровно за один шаг до конца. Для реализации вычитания единицы сделаем следующее. <tex>n</tex> раз выполним следующее: имея пару <tex>\langle n-1, n-2\rangle</tex> построим пару <tex>\langle n, n-1\rangle</tex>. Тогда после <tex>n</tex> шагов во втором элементе пары будет записано число <tex>n-1</tex>, которое и хочется получить.

<tex>\operatorname{pred} = \lambda n \to \lambda s \to \lambda z \to\ \operatorname{snd} (
n\ (
\lambda p \to \operatorname{pair}\ (s\ (\operatorname{fst} p))\ (\operatorname{fst} p)
)\ (\operatorname{pair}\ z\ z)</tex>

Если вы ничего не поняли, не огорчайтесь. Вычитание придумал Клини, когда ему вырывали зуб мудрости. А сейчас наркоз уже не тот.

===Сравнение===
Так как вычитание определено таким способом, чтобы для случая, в котором уменьшаемое больше, чем вычитаемое, возвращать ноль, можно определить сравнение на больше-меньше через него. Равными же числа <tex>a</tex> и <tex>b</tex> считаются, если <tex>a - b = 0 \wedge b - a = 0</tex>.

<tex>\operatorname{le} = \lambda n \to \lambda m \to \operatorname{isZero}\ (\operatorname{minus}\ n\ m)</tex>

<tex>\operatorname{less} = \lambda n \to \lambda m \to \operatorname{le}\ n\ (\operatorname{pred} m)</tex>

<tex>\operatorname{eq} = \lambda n \to \lambda m \to \operatorname{and}\ (\operatorname{isZero}\ (\operatorname{minus}\ n\ m))\
(\operatorname{isZero}\ (\operatorname{minus}\ m\ n))</tex>

===Комбинатор неподвижной точки===
Попробуем выразить в лямбда-исчислении какую-нибудь функцию, использующую рекурсию. Напрмер, факториал.

<tex>\operatorname{fact} = \lambda x \to \operatorname{if}\ (\operatorname{isZero}\ x)\ \bar 1\ (\operatorname{fact}\ (\operatorname{pred}\ x))</tex>

Мы столкнулись с проблемой. В определении функции <tex>\operatorname{fact}</tex> используется функция <tex>\operatorname{fact}</tex>. При формальной замене, получим бесконечную функцию. Можно попытаться решить эту проблему следующим образом

<tex>\operatorname{fact} = (\lambda f \to \lambda x \to \operatorname{if}\ (\operatorname{isZero}\ x)\ \bar 1\ (f\ (\operatorname{pred}\ x)))\ \operatorname{fact}</tex>

{{Определение
|definition=''Неподвижной точкой'' лямбда-функции <tex>f</tex> назовём такую функцию <tex>x</tex>, что
<tex>f\ x \to_\beta x</tex>.
}}

Лямбда исчисление обладаем замечательным свойством: у каждой функции есть неподвижная точка!

Рассмотрим следующую функцию.

<tex>\operatorname{fix} = \lambda f \to (\lambda x \to f\ (x\ x))\ (\lambda x \to f\ (x\ x))</tex>

Заметим, что <tex>\operatorname{fix} \to_\beta \lambda f \to f\ ((\lambda x \to f\ (x\ x))\ (\lambda x \to f\ (x\ x)))</tex>.
Или, что то же самое,
<tex>\lambda f \to (\lambda x \to f\ (x\ x))\ (\lambda x \to f\ (x\ x)) \to_\beta</tex>
<tex>\lambda f \to f\ ((\lambda x \to f\ (x\ x))\ (\lambda x \to f\ (x\ x)))</tex>

Рассмотрим функцию

<tex>\operatorname{fact'} = \lambda f \to \lambda x \to \operatorname{if}\ (\operatorname{isZero}\ x)\ \bar 1\ (\operatorname{mult}\ x\ (f\ (\operatorname{pred}\ x)))</tex>

Как было показано выше, <tex>\operatorname{fix} f \to_\beta f\ (\operatorname{fix} f)</tex>, то есть, <tex>\operatorname{fix}\ \operatorname{fact'} \to_\beta \operatorname{fact}</tex>, где <tex>\operatorname{fact}</tex> {{---}} искомая функция, считающая факториал.

<tex>\operatorname{fact} = \operatorname{fix}\ \operatorname{fact'}</tex>

Это даст функцию, которая посчитает факториал числа. Но делать она это будет мееедленно-меееедленно. Для того, чтобы посчитать <tex?5!</tex> потребовалось сделать 66066 <tex>\beta</tex>-редукций.

Тут правда ничего не понятно? :'(

===Деление===
Воспользовавшись идеей о том, что можно делать рекурсивные функции, сделаем функцию, которая будет искать частное двух чисел.

<tex>\operatorname{div'} = \lambda div \to \lambda n \to \lambda m \to \operatorname{if}\ (\operatorname{less}\ n\ m)\ \bar 0\ (\operatorname{succ}\ (div\ (\operatorname{minus}\ n\ m)\ m))</tex>

<tex>\operatorname{div} = \operatorname{fix}\ \operatorname{div'}</tex>

И остатка от деления

<tex>\operatorname{mod'} = \lambda mod \to \lambda n \to \lambda m \to \operatorname{if}\ (\operatorname{less}\ n\ m)\ n\ (mod\ (\operatorname{minus}\ n\ m)\ m)</tex>

<tex>\operatorname{mod} = \operatorname{fix}\ \operatorname{mod'}</tex>

===Проверка на простоту===

<tex>\operatorname{isPrimeHelp}</tex> {{---}} принимает число, которое требуется проверить на простоту и то, на что его надо опытаться поделить, перебирая это от 2 до <tex>p-1</tex>. Если на что-нибудь разделилось, то число {{---}} составное, иначе {{---}} простое.

<tex>\operatorname{isPrimeHelp'} =</tex><tex>\lambda f \to \lambda p \to \lambda i \to \operatorname{if}\ (\operatorname{le}\ p\ i)\ \operatorname{true}\ (\operatorname{if}\ (\operatorname{isZero}\ (\operatorname{mod}\ p\ i))\ \operatorname{false}\ (f\ p\ (\operatorname{succ}\ i)))</tex>

<tex>\operatorname{isPrimeHelp} = \operatorname{fix}\ \operatorname{isPrimeHelp'}</tex>

<tex>\operatorname{isPrime} = \lambda p \to \operatorname{isPrimeHelp}\ p\ \bar 2</tex>

Следующее простое число. <tex>\operatorname{nextPrime'}</tex> {{---}} следующее, больше либо равное заданного, <tex>\operatorname{nextPrime}</tex> {{---}} следующее, большее заданного.

<tex>\operatorname{nextPrime''} = \lambda f \to \lambda p \to \operatorname{if}\ (\operatorname{isPrime}\ p)\ p\ (f\ (\operatorname{succ}\ p)) </tex>

<tex>\operatorname{nextPrime'} = \operatorname{fix}\ \operatorname{nextPrime'}</tex>

<tex>\operatorname{nextPrime} = \lambda p \to \operatorname{nextPrime'}\ (\operatorname{succ}\ p)</tex>

<tex>\operatorname{ithPrimeStep}</tex> пропрыгает <tex>i</tex> простых чисел вперёд. <tex>\operatorname{ithPrime}</tex> принимает число <tex>i</tex> и пропрыгивает столько простых чисел вперёд, начиная с двойки.

<tex>\operatorname{ithPrimeStep'} = \lambda f \to \lambda p \to \lambda i \to \operatorname{if}\ (\operatorname{isZero}\ i)\ p\ (f\ (\operatorname{nextPrime}\ p)\ (\operatorname{pred}\ i))</tex>

<tex>\operatorname{ithPrimeStep} = \operatorname{fix}\ \operatorname{ithPrimeStep'}</tex>

<tex>\operatorname{ithPrime} = \lambda i \to \operatorname{ithPrimeStep}\ \bar 2\ i</tex>

...и всего через 314007 <tex>\beta</tex>-редукций вы узнаете, что третье простое число {{---}} семь!

\subsection{Списки}

Для работы со списками чисел нам понадобятся следующие функции:
\begin{itemize}
\item $empty$~--- возвращает пустой список
\item $cons$~--- принимает первый элемент и оставшийся список, склеивает их
\item $head$~--- вернуть голову списка
\item $tail$~--- вернуть хвост списка
\end{itemize}

Список будем хранить в следующем виде: $\langle len, p_1^{a_1}p_2^{a_2}\ldots p_{len}^{a_{len}} \rangle$. При этом, голова списка будет храниться как показатель степени при $p_{len}$.

\begin{code}
empty = pair' `App` zero' `App` one'
cons = Lam "h" $ Lam "t" $ pair' `App` (succ' `App` (fst'' `App` Var "t"))
`App` (mult' `App` (snd'' `App` Var "t") `App` (power'
`App` (ithPrime `App` (fst'' `App` Var "t"))
`App` Var "h"
))
head = Lam "list" $ getExponent `App` (snd'' `App` Var "list")
`App` (ithPrime `App` (pred' `App` (fst'' `App` Var "list")))

tail = Lam "list" $ pair' `App` (pred' `App` (fst'' `App` Var "list"))
`App` (eliminateMultiplier `App` (snd'' `App` Var "list")
`App` (ithPrime `App` (pred' `App` (fst'' `App` Var "list" )))
)

eliminateMultiplier' = Lam "f" $ Lam "n" $ Lam "m" $ if'' `App` (isZero' `App` (mod' `App` Var "n" `App` Var "m"))
`App` (Var "f" `App` (div' `App` Var "n" `App` Var "m") `App` Var "m")
`App` Var "n"
eliminateMultiplier = fix' `App` eliminateMultiplier'

getExponent' = Lam "f" $ Lam "n" $ Lam "m" $ if'' `App` (isZero' `App` (mod' `App` Var "n" `App` Var "m"))
`App` (succ' `App`(Var "f" `App` (div' `App` Var "n" `App` Var "m") `App` Var "m"))
`App` zero'
getExponent = fix' `App` getExponent'
\end{code}

На основе этого всего уже можно реализовать эмулятор машины тьюринга:
с помощью пар, списков чисел можно хранить состояния. С помощью рекурсии можно
обрабатывать переходы. Входная строка будет даваться, например, закодированной
аналогично списку: пара из длины и числа, характеризующего список степенями
простых. Я бы продолжил это писать, но уже на операции $head [1, 2]$ я не
дождался окончания выполнения. Скорость лямбда-исчисления как вычислителя
печальна.

\ignore{
\begin{code}

four' = norm $ succ' `App` three'
five' = norm $ succ' `App` four'

list2 = norm $ cons `App` one' `App` empty
list32 = cons `App` zero' `App` list2

normFiveFact = normIO 0 $ fact' `App` five'

-- fiftysix = mult twentyeight two
-- fiftyfive = pred fiftysix
-- six = pred seven

--main = do print $ fiftysix (+1) 0
main = do
-- f <- normIO 0 $ ithPrime `App` three'
-- f <- normIO 0 $ getExponent `App` (norm $ plus' `App` four' `App` four') `App` two'
f <- normIO 0 $ head `App` (tail `App` list32)
print $ toInt f
\end{code}
}

\end{document}
[http://rain.ifmo.ru/~komarov/Turing.lhs]

Лямбда-исчисление

2012-12-06T16:14:27Z

194.85.160.130: /* Логические значения */

{{В разработке}}

== Лямбда-исчисление==

''Лямбда-исчисление'' {{---}} формальная система, придуманная в 1930-х годах
Алонзо Чёрчем. Лямбда-функция является, по сути, анонимной функцией.
Эта концепция показала себя удобной и сейчас активно используется во многих
языках программирования.

Более формально, ''лямбда-функцию'' (или, ''лямбда-терм'') можно задать
следующей грамматикой:
{{Определение
|definition=
<tex>
\begin{array}{r c l}
\langle Term \rangle & ::= & \langle Variable \rangle \\
& || & \langle Term \rangle \langle Term \rangle \\
& || & \lambda \langle Variable \rangle \to \langle Term \rangle\\
& || & ( \langle Term \rangle )\\
\langle Variable \rangle & ::= & \langle Char \rangle *\\
\end{array}
</tex>
}}

В первом случае функция является просто переменной.
Во втором происходит ''аппликация'' (''применение'') одной функции к другой.
Это аналогично вычислению функции-левого операнда на аргументе-правом операнде.
В третьем {{---}} ''абстракция'' по переменной. В данном случае происходит
создание функции одного аргумента с заданными именем аргумента и телом функции.

Рассмотрим, например, функцию <tex>id = \lambda x \to x</tex>. Эта функция принимает аргумент и
возвращает его неизменённым. Например,
<tex>id 2 \equiv 2</tex>. Аналогично, <tex>id y == y</tex>.

Ещё один пример функции: <tex>sum = \lambda x \to \lambda y \to x + y|. Эта функция двух аргументов,
которая возвращает их сумму. Правда, здесь мы немного вышли за написанную выше грамматику.
Ну да ладно. <tex>sum 2 3 == 5</tex>

===Приоритет операций===
* Применение левоассоциативно: <tex>x y z w == ((x y) z) w</tex>
* Аппликация забирает себе всё, до чего дотянется: <tex>\lambda x \to \lambda y \to \lambda z \to z y x \equiv \lambda x \to (\lambda y \to (\lambda z \to ((z y) x)))</tex>
* Скобки играют привычную роль группировки действий

===Свободные и связанные переменные===
''Связанными'' переменными называются все переменные, по которым выше в
дереве разбора были абстракции. Все остальные переменные называются свободными.

Например, в <tex>\lambda x \to \lambda y \to x</tex>, <tex>x</tex> связана, а <tex>y</tex>{{---}} свободна. А в <tex>\lambda y \to x (\lambda x \to x)</tex>
в своём первом вхождении переменная <tex>x</tex> свободна, а во втором {{---}} связана.

Рассмотрим функции <tex>\lambda y \to y</tex> и <tex>\lambda x \to y</tex>. В первой из них при взгляде на <tex>y</tex>
понятно, что она имеет отношение к переменной, по которой производилась
абстракция. Если по одной и той же
переменной абстракция производилась более одного раза, то переменная связана
с самым поздним (самым нижним в дереве разбора) абстрагированием. Например, в
<tex>\lambda x \to \lambda x \to \lambda y \to \lambda x \to x</tex>, переменная <tex>x</tex> связана с самой правой абстракцией
по <tex>x</tex>.

===<tex>\alpha</tex>-конверсия===

Рассмотрим функции <tex>(\lambda x \to x) z</tex> и <tex>(\lambda y \to y) z</tex>. Интуитивно понятно, что они
являются одинаковыми.

{{Определение
|definition=''<tex>\alpha</tex>-конверсия'' {{---}} переименование связанной переменной. Выражение
<tex>\lambda x \to f</tex> можно заменить на <tex>\lambda y \to f[x := y]</tex>, если <tex>y</tex> не входит свободно в <tex>f</tex>,
где <tex>f[x:=y]</tex> означает замену всех свободных вхождений <tex>x</tex> в <tex>f</tex> на <tex>y</tex>.
}}

Функции, получающиеся одна из другой с помощью <tex>\alpha</tex>-конверсий, называются
''<tex>\alpha</tex>-эквивалентными'' и обозначаются <tex>f \equiv_\alpha g</tex>.

Функции <tex>\lambda x \to \lambda y \to x y z</tex> и <tex>\lambda a \to \lambda x \to a x z</tex> являются <tex>\alpha</tex>-эквивалентными,
а <tex>\lambda x \to \lambda y \to y z</tex> и <tex>\lambda y \to \lambda x \to y z</tex> {{---}} нет.

===<tex>\beta</tex>-редукция===

{{Определение
|definition=
<tex>\beta</tex>-редукция олицетворяет идею счёта значения функции. Выражение вида
<tex>(\lambda x \to f) y</tex> можно заменить на <tex>f[x := y]</tex>, где <tex>f[x:=y]</tex>, как и ранее, означает
замену всех свободных вхождений <tex>x</tex> в <tex>f</tex> на <tex>y</tex>.
}}

{{Определение
|definition=
Через <tex>f \to_\beta g</tex> обозначают сведение <tex>f</tex> к <tex>g</tex> с помощью одной <tex>\beta</tex>-редукции.
А через <tex>f \to_\beta^* g</tex> {{---}} за ноль или более.
}}

===<tex>\eta</tex>-редукция===
Рассмотрим выражение вида <tex>\lambda x \to f x</tex>. Если подставить в эту функцию значение
<tex>y</tex>, то получим: <tex>(\lambda x \to f x) y \to_\beta f y</tex>. Но если просто подставить
<tex>y</tex> в <tex>f</tex>, то получится то же самое.

{{Определение
|definition=
<tex>\eta</tex>-редукция {{---}} преобразование <tex>\lambda x \to f x</tex> в <tex>f</tex>.
}}

==Нотация Де Брюина==
Существует также альтернативное эквивалентное определение <tex>\lambda</tex>-исчисления.
В оригинальном определении для обозначения переменных использовались имена,
и была проблема с тем, что не были запрещены одинаковые имена в разных
абстракциях.

От этой проблемы можно избавиться следующим образом. Вместо имени переменной
будет храниться натуральное число {{---}} количество абстракций в дереве разбора,
на которое нужно подняться, чтобы найти ту лямбду, с которой данная переменная
связана. В данной нотации получаются несколько более простые определения
свободных переменных и <tex>\beta</tex>-редукции.

Переменная называется свободной, если ей соответствует число, которое больше
количества абстракций на пути до неё в дереве разбора.

При <tex>\beta</tex>-редукции же нужно будет ко всем свободным переменным заменяющего
дерева при каждой замене прибавить число, равное разницы уровней раньше и сейчас.
Это будет соответствовать тому, что эта переменная продолжит <<держаться>> за
ту же лямбду, что и раньше.

==Нумералы Чёрча и программирование на <tex>\lambda</tex>-исчислении==

===Определение===
Введём на основе лямбда-исчисления аналог натуральных чисел, основанный на идее,
что натуральное число {{---}} это или ноль, или увеличенное на единицу натуральное
число.

* <tex>\bar 0 = \lambda s \to \lambda z \to z</tex>
* <tex>\bar 1 = \lambda s \to \lambda z \to s z</tex>
* <tex>\bar 2 = \lambda s \to \lambda z \to s (s z)</tex>
* <tex>\bar 3 = \lambda s \to \lambda z \to s (s (s z))</tex>

Каждое число будет функцией двух аргументов: какой-то функции и начального значения.
Число <tex>n</tex> будет <tex>n</tex> раз применять функцию к начальному значению и возвращать
результат. Если такому <<числу>> дать на вход функцию <tex>(+1)</tex> и <tex>0</tex> в качестве
начального значения, то на выходе как раз будет ожидаемое от функции число:
<tex>\bar 3 (+1) 0 \equiv 3</tex>.

===+1===
Функция, прибавляющая 1 к числу, должна принимать первым аргументом число.
Но число {{---}} функция двух аргументов. Значит, эта функция должна принимать три
аргумента: <<число>> <tex>n</tex>, которое хочется увеличить, функция, которую надо будет
<tex>n+1</tex> раз применить, и начальное значение.

<tex>\operatorname{succ} = \lambda n \to \lambda s \to \lambda z \to s (n s z)</tex>

Здесь <tex>n s z</tex> {{---}} <tex>n</tex> раз применённая к <tex>z</tex> функция <tex>s</tex>. Но нужно применить <tex>n+1</tex>
раз. Отсюда <tex>s (n s z)</tex>.

===Сложение===
Сложение двух чисел похоже на прибавление единицы. Но только надо прибавить не единицу, а второе число.

<tex>\operatorname{plus} = \lambda n \to \lambda m \to \lambda s \to \lambda z \to n s (m s z)</tex>

<tex>n</tex> раз применить <tex>s</tex> к применённому <tex>m</tex> раз <tex>s</tex> к <tex>z</tex>

<tex>(\operatorname{plus} \bar 3 \bar 3) (+1) 0 \equiv 6</tex>

===Умножение===
Умножение похоже на сложение, но прибавлять надо не единицу, а второе число.
Или, в терминах нумералов Чёрча, в качестве применяемой несколько раз
функции должна быть не <tex>s</tex>, а функция, применяющая <tex>n</tex> раз <tex>s</tex>.

<tex>\operatorname{mult} = \lambda n \to \lambda m \to \lambda s \to n (m s)</tex>

Здесь <tex>m s</tex> {{---}} функция, которая <tex>m</tex> раз применит <tex>s</tex> к тому, что дадут ей на
вход. С помощью <tex>\eta</tex>-редукции можно немного сократить эту формулу

<tex>\operatorname{mult} = \lambda n \to \lambda m \to \lambda s \to n (m s)</tex>

<tex>(\operatorname{mult} \bar 3 \bar 3) (+1) 0 \equiv 9</tex>

===Возведение в степень===
It's a kind of magic

<tex>\operatorname{power} = \lambda n \to \lambda m \to m n</tex>

<tex>(\operatorname{power} \bar 3 (\operatorname{succ} \bar 3)) (+1) 0 \equiv 81</tex>

===Логические значения===
<tex>\operatorname{true} = \lambda a \to \lambda b \to a</tex>

<tex>\operatorname{false} = \lambda a \to \lambda b \to b</tex>

Функции двух аргументов, возвращающие первый и второй, соответственное, аргументы.
Забавный факт: <tex>\operatorname{false} \equiv_\alpha \operatorname{zero}</tex>. Эти функции сделаны такими для того,
чтобы красиво написать функцию <tex>\operatorname{if}</tex>:

<tex>\operatorname{if} = \lambda p \to \lambda t \to \lambda e \to p t e</tex>

Если ей в качестве первого аргумента дадут <tex>\operatorname{true}</tex>, то вернётся <tex>t</tex>, иначе {{---}} <tex>e</tex>.

Стандартные функции булевой логики:

<tex>\operatorname{and} = \lambda n \to \lambda m \to \operatorname{if} n m \operatorname{false}</tex>

<tex>\operatorname{or} = \lambda n \to \lambda m \to \operatorname{if} n \operatorname{true} m</tex>

<tex>\opeartorname{not} = \lambda b \to \opeartorname{if} b \operatorname{false} \operatorname{true}</tex>

Ещё одной важной функцией является функция проверки, является ли число нулём:

<tex>\operatorname{isZero} = \lambda n \to n (\lambda c \to \operatorname{false}) \operatorname{true}</tex>

Функция выглядит несколько странно. <tex>\lambda c -> \operatorname{false}</tex> {{---}} функция, которая независимо
от того, что ей дали на вход, возвращает <tex>\operatorname{false}</tex>. Тогда, если в качестве <tex>n</tex>
будет дан ноль, то функция, по определению нуля, не выполнится ни разу, и будет
возвращено значение по умолчанию <tex>\operatorname{true}</tex>. Иначе же функция будет запущено, и
вернётся <tex>\operatorname{false}</tex>.

\subsection{Пара}

\begin{code}
pair' = Lam "a" $ Lam "b" $ Lam "t" $ Var "t" `App` Var "a" `App` Var "b"
fst'' = Lam "p" $ Var "p" `App` true'
snd'' = Lam "p" $ Var "p" `App` false'
\end{code}

Функция $pair$ принимает два значения и запаковывает их в пару так, чтобы к
ним можно было обращаться по $fst$ и $snd$. В $fst$ и $snd$ вместо $t$ в $pair$
будет подставлено $true$ или $false$, возвращающие, соответственно, первый и
второй аргументы, то есть $a$ или $b$, соответственно.

\subsection{Вычитание}
В отличие от всех предыдущих функций, вычитание для натуральных чисел определено
только в случае, если уменьшаемое больше вычитаемого. Положим в противном случае
результат равным нулю. Пусть уже есть функция, которая вычитает из числа единицу.
Тогда на её основе легко сделать, собственно, вычитание.

\begin{code}
minus' = Lam "n" $ Lam "m" $ Var "m" `App` pred' `App` Var "n"
\end{code}

<<$m$ раз вычесть единицу из $n$>>.

Осталось, собственно, функция для вычитания единицы. Однако, это не так просто,
как может показаться на первый взгляд. Проблема в том, что, имея функцию, которую
нужно применить для того, чтобы продвинуться вперёд, продвинуться назад будет
проблематично. Если попробовать воспользоваться идеей о том, чтобы, начав от
нуля, идти вперёд, и пройти на один шаг меньше, то будет не очень понятно, как
же остановиться ровно за один шаг до конца. Для реализации вычитания единицы
сделаем следующее. $n$ раз выполним следующее: имея пару $(n-1, n-2)$ построим пару
$(n, n-1)$. Тогда после $n$ шагов во втором элементе пары будет записано число
$n-1$, которое и хочется получить.
% --pred = \n -> \s -> \z -> n (\g -> \h -> h (g s)) (\u -> z) (\u->u)
% --pred = \n -> \s -> \z -> snd (n (\p -> (pair (s (fst p)) (fst p))) (pair z z))
% --pred = \n -> \s -> \z -> fst' (n (\p -> pair (s (fst p))(fst p)) (pair z z))

\begin{code}
pred' = Lam "n" $
Lam "s" $
Lam "z" $
snd'' `App` (Var "n"
`App` (
Lam "p" $ pair'
`App` (Var "s" `App` (fst'' `App` Var "p"))
`App` (fst'' `App` Var "p")
)
`App` ( pair' `App` Var "z" `App` Var "z" )
)
\end{code}

Если вы ничего не поняли, не огорчайтесь. Вычитание придумал Клини, когда
ему вырывали зуб мудрости. А сейчас наркоз уже не тот!

\subsection{Сравнение}
Так как вычитание определено таким способом, чтобы для случая, в котором
уменьшаемое больше, чем вычитаемое, возвращать ноль, можно определить
сравнение на больше-меньше через него. Равными же числа $a$ и $b$ считаются,
если $a - b = 0 \wedge b - a = 0$.

\begin{code}
le' = Lam "n" $ Lam "m" $ isZero' `App` (minus' `App` Var "n" `App` Var "m")
less' = Lam "n" $ Lam "m" $ le' `App` Var "n" `App` (pred' `App` Var "m")
eq' = Lam "n" $ Lam "m" $ and'
`App` (isZero' `App` (minus' `App` Var "n" `App` Var "m"))
`App` (isZero' `App` (minus' `App` Var "m" `App` Var "n"))
\end{code}

\subsection{Комбинатор неподвижной точки}
Попробуем выразить в лямбда-исчислении какую-нибудь рекурсивную функцию.
Напрмер, факториал.

\begin{spec}
fact = \x -> if (isZero x) one (fact (pred x))
\end{spec}

Мы столкнулись с проблемой. В определении функции $fact$ используется функция
$fact$. При формальной замене, получим бесконечную функцию. Можно попытаться решить
эту проблему следующим образом

\begin{spec}
fact = (\f -> \x -> if (isZero x) one (f (pred x))) fact
\end{spec}

\emph{Неподвижной точкой} лямбда-функции $f$ назовём такую функцию $x$, что
$f x \to_\beta x$. Лямбда исчисление обладаем замечательным свойством: у каждой
функции есть неподвижная точка!

Рассмотрим такую функцию.

\begin{code}
fix' = Lam "f" $ (Lam "x" $ Var "f" `App` (Var "x" `App` Var "x"))
`App` (Lam "x" $ Var "f" `App` (Var "x" `App` Var "x"))
\end{code}

Заметим, что $fix' \to_\beta \lambda f \to f ((\lambda x \to f (x x)) (\lambda x \to f (x x)))$.
Или, что то же самое,
$\lambda f \to (\lambda x \to f (x x)) (\lambda x \to f (x x)) \to_\beta
\lambda f \to f ((\lambda x \to f (x x)) (\lambda x \to f (x x)))$

Рассмотрим функцию

\begin{code}
fact'' = Lam "f" $ Lam "x" $ if'' `App` (isZero' `App` Var "x")
`App` one'
`App` (mult' `App` Var "x" `App` (Var "f" `App`
(pred' `App` Var "x")))
\end{code}

Как было показано выше, $fix f \to_\beta f (fix f)$, то есть,
$fix fact'' \to_\beta fact'$, где $fact'$~--- искомая функция, считающая факториал.

\begin{code}
fact' = fix' `App` fact''
\end{code}

Это даст функцию, которая посчитает факториал числа. Но делать она это будет
мееедленно-меееедленно. Для того, чтобы посчитать $5!$ потребовалось сделать
66066 $\beta$-редукций.

Тут правда ничего не понятно? :'(

\subsection{Деление}
Воспользовавшись идеей о том, что можно делать рекурсивные функции, сделаем
функцию, которая будет искать частное двух чисел.

\begin{code}
div'' = Lam "div" $ Lam "n" $ Lam "m" $ if'' `App` (less' `App` Var "n" `App` Var "m")
`App` zero'
`App` (succ' `App` (Var "div" `App` (minus' `App` Var "n" `App` Var "m") `App` Var "m"))
div' = fix' `App` div''
\end{code}

И остатка от деления

\begin{code}
mod'' = Lam "mod" $ Lam "n" $ Lam "m" $ if'' `App` (less' `App` Var "n" `App` Var "m")
`App` Var "n"
`App` (Var "mod" `App` (minus' `App` Var "n" `App` Var "m") `App` Var "m")
mod' = fix' `App` mod'';
\end{code}

\subsection{Проверка на простоту}

$isPrimeHelp$~--- принимает число, которое требуется проверить на простоту и
то, на что его надо попытаться поделить, перебирая это от 2 до $p-1$. Если на
что-нибудь разделилось, то число~--- составное, иначе~--- простое.

\begin{code}
isPrimeHelp' = Lam "f" $ Lam "p" $ Lam "i" $ if'' `App` (le' `App` Var "p" `App` Var "i")
`App` true'
`App` ( if'' `App` (isZero' `App` (mod' `App` Var "p" `App` Var "i"))
`App` false'
`App` (Var "f" `App` Var "p" `App` (succ' `App` Var "i"))
)
isPrimeHelp = fix' `App` isPrimeHelp'
isPrime = Lam "p" $ isPrimeHelp `App` Var "p" `App` two'
\end{code}

Следующее простое число. $nextPrime'$~--- следующее, больше либо равное заданного,
$nextPrime$~--- следующее, большее заданного.

\begin{code}
nextPrime'' = Lam "f" $ Lam "p" $ if'' `App` (isPrime `App` Var "p")
`App` Var "p"
`App` (Var "f" `App` (succ' `App` Var "p"))
nextPrime' = fix' `App` nextPrime''
nextPrime = Lam "p" $ nextPrime' `App` (succ' `App` Var "p")
\end{code}

$ithPrimeStep$ пропрыгает $i$ простых чисел вперёд. $ithPrime$ принимает число
$i$ и пропрыгивает столько простых чисел вперёд, начиная с двойки.

\begin{code}
ithPrimeStep' = Lam "f" $ Lam "p" $ Lam "i" $ if'' `App` (isZero' `App` Var "i")
`App` Var "p"
`App` (Var "f" `App` (nextPrime `App` Var "p") `App` (pred' `App` Var "i"))
ithPrimeStep = fix' `App` ithPrimeStep'
ithPrime = Lam "i" $ ithPrimeStep `App` two' `App` Var "i"
\end{code}

...и всего через 314007 $\beta$-редукций вы узнаете, что третье простое число~---
семь!

\subsection{Списки}

Для работы со списками чисел нам понадобятся следующие функции:
\begin{itemize}
\item $empty$~--- возвращает пустой список
\item $cons$~--- принимает первый элемент и оставшийся список, склеивает их
\item $head$~--- вернуть голову списка
\item $tail$~--- вернуть хвост списка
\end{itemize}

Список будем хранить в следующем виде: $\langle len, p_1^{a_1}p_2^{a_2}\ldots p_{len}^{a_{len}} \rangle$. При этом, голова списка будет храниться как показатель степени при $p_{len}$.

\begin{code}
empty = pair' `App` zero' `App` one'
cons = Lam "h" $ Lam "t" $ pair' `App` (succ' `App` (fst'' `App` Var "t"))
`App` (mult' `App` (snd'' `App` Var "t") `App` (power'
`App` (ithPrime `App` (fst'' `App` Var "t"))
`App` Var "h"
))
head = Lam "list" $ getExponent `App` (snd'' `App` Var "list")
`App` (ithPrime `App` (pred' `App` (fst'' `App` Var "list")))

tail = Lam "list" $ pair' `App` (pred' `App` (fst'' `App` Var "list"))
`App` (eliminateMultiplier `App` (snd'' `App` Var "list")
`App` (ithPrime `App` (pred' `App` (fst'' `App` Var "list" )))
)

eliminateMultiplier' = Lam "f" $ Lam "n" $ Lam "m" $ if'' `App` (isZero' `App` (mod' `App` Var "n" `App` Var "m"))
`App` (Var "f" `App` (div' `App` Var "n" `App` Var "m") `App` Var "m")
`App` Var "n"
eliminateMultiplier = fix' `App` eliminateMultiplier'

getExponent' = Lam "f" $ Lam "n" $ Lam "m" $ if'' `App` (isZero' `App` (mod' `App` Var "n" `App` Var "m"))
`App` (succ' `App`(Var "f" `App` (div' `App` Var "n" `App` Var "m") `App` Var "m"))
`App` zero'
getExponent = fix' `App` getExponent'
\end{code}

На основе этого всего уже можно реализовать эмулятор машины тьюринга:
с помощью пар, списков чисел можно хранить состояния. С помощью рекурсии можно
обрабатывать переходы. Входная строка будет даваться, например, закодированной
аналогично списку: пара из длины и числа, характеризующего список степенями
простых. Я бы продолжил это писать, но уже на операции $head [1, 2]$ я не
дождался окончания выполнения. Скорость лямбда-исчисления как вычислителя
печальна.

\ignore{
\begin{code}

four' = norm $ succ' `App` three'
five' = norm $ succ' `App` four'

list2 = norm $ cons `App` one' `App` empty
list32 = cons `App` zero' `App` list2

normFiveFact = normIO 0 $ fact' `App` five'

-- fiftysix = mult twentyeight two
-- fiftyfive = pred fiftysix
-- six = pred seven

--main = do print $ fiftysix (+1) 0
main = do
-- f <- normIO 0 $ ithPrime `App` three'
-- f <- normIO 0 $ getExponent `App` (norm $ plus' `App` four' `App` four') `App` two'
f <- normIO 0 $ head `App` (tail `App` list32)
print $ toInt f
\end{code}
}

\end{document}
[http://rain.ifmo.ru/~komarov/Turing.lhs]

Лямбда-исчисление

2012-12-06T16:13:16Z

194.85.160.130:

{{В разработке}}

== Лямбда-исчисление==

''Лямбда-исчисление'' {{---}} формальная система, придуманная в 1930-х годах
Алонзо Чёрчем. Лямбда-функция является, по сути, анонимной функцией.
Эта концепция показала себя удобной и сейчас активно используется во многих
языках программирования.

Более формально, ''лямбда-функцию'' (или, ''лямбда-терм'') можно задать
следующей грамматикой:
{{Определение
|definition=
<tex>
\begin{array}{r c l}
\langle Term \rangle & ::= & \langle Variable \rangle \\
& || & \langle Term \rangle \langle Term \rangle \\
& || & \lambda \langle Variable \rangle \to \langle Term \rangle\\
& || & ( \langle Term \rangle )\\
\langle Variable \rangle & ::= & \langle Char \rangle *\\
\end{array}
</tex>
}}

В первом случае функция является просто переменной.
Во втором происходит ''аппликация'' (''применение'') одной функции к другой.
Это аналогично вычислению функции-левого операнда на аргументе-правом операнде.
В третьем {{---}} ''абстракция'' по переменной. В данном случае происходит
создание функции одного аргумента с заданными именем аргумента и телом функции.

Рассмотрим, например, функцию <tex>id = \lambda x \to x</tex>. Эта функция принимает аргумент и
возвращает его неизменённым. Например,
<tex>id 2 \equiv 2</tex>. Аналогично, <tex>id y == y</tex>.

Ещё один пример функции: <tex>sum = \lambda x \to \lambda y \to x + y|. Эта функция двух аргументов,
которая возвращает их сумму. Правда, здесь мы немного вышли за написанную выше грамматику.
Ну да ладно. <tex>sum 2 3 == 5</tex>

===Приоритет операций===
* Применение левоассоциативно: <tex>x y z w == ((x y) z) w</tex>
* Аппликация забирает себе всё, до чего дотянется: <tex>\lambda x \to \lambda y \to \lambda z \to z y x \equiv \lambda x \to (\lambda y \to (\lambda z \to ((z y) x)))</tex>
* Скобки играют привычную роль группировки действий

===Свободные и связанные переменные===
''Связанными'' переменными называются все переменные, по которым выше в
дереве разбора были абстракции. Все остальные переменные называются свободными.

Например, в <tex>\lambda x \to \lambda y \to x</tex>, <tex>x</tex> связана, а <tex>y</tex>{{---}} свободна. А в <tex>\lambda y \to x (\lambda x \to x)</tex>
в своём первом вхождении переменная <tex>x</tex> свободна, а во втором {{---}} связана.

Рассмотрим функции <tex>\lambda y \to y</tex> и <tex>\lambda x \to y</tex>. В первой из них при взгляде на <tex>y</tex>
понятно, что она имеет отношение к переменной, по которой производилась
абстракция. Если по одной и той же
переменной абстракция производилась более одного раза, то переменная связана
с самым поздним (самым нижним в дереве разбора) абстрагированием. Например, в
<tex>\lambda x \to \lambda x \to \lambda y \to \lambda x \to x</tex>, переменная <tex>x</tex> связана с самой правой абстракцией
по <tex>x</tex>.

===<tex>\alpha</tex>-конверсия===

Рассмотрим функции <tex>(\lambda x \to x) z</tex> и <tex>(\lambda y \to y) z</tex>. Интуитивно понятно, что они
являются одинаковыми.

{{Определение
|definition=''<tex>\alpha</tex>-конверсия'' {{---}} переименование связанной переменной. Выражение
<tex>\lambda x \to f</tex> можно заменить на <tex>\lambda y \to f[x := y]</tex>, если <tex>y</tex> не входит свободно в <tex>f</tex>,
где <tex>f[x:=y]</tex> означает замену всех свободных вхождений <tex>x</tex> в <tex>f</tex> на <tex>y</tex>.
}}

Функции, получающиеся одна из другой с помощью <tex>\alpha</tex>-конверсий, называются
''<tex>\alpha</tex>-эквивалентными'' и обозначаются <tex>f \equiv_\alpha g</tex>.

Функции <tex>\lambda x \to \lambda y \to x y z</tex> и <tex>\lambda a \to \lambda x \to a x z</tex> являются <tex>\alpha</tex>-эквивалентными,
а <tex>\lambda x \to \lambda y \to y z</tex> и <tex>\lambda y \to \lambda x \to y z</tex> {{---}} нет.

===<tex>\beta</tex>-редукция===

{{Определение
|definition=
<tex>\beta</tex>-редукция олицетворяет идею счёта значения функции. Выражение вида
<tex>(\lambda x \to f) y</tex> можно заменить на <tex>f[x := y]</tex>, где <tex>f[x:=y]</tex>, как и ранее, означает
замену всех свободных вхождений <tex>x</tex> в <tex>f</tex> на <tex>y</tex>.
}}

{{Определение
|definition=
Через <tex>f \to_\beta g</tex> обозначают сведение <tex>f</tex> к <tex>g</tex> с помощью одной <tex>\beta</tex>-редукции.
А через <tex>f \to_\beta^* g</tex> {{---}} за ноль или более.
}}

===<tex>\eta</tex>-редукция===
Рассмотрим выражение вида <tex>\lambda x \to f x</tex>. Если подставить в эту функцию значение
<tex>y</tex>, то получим: <tex>(\lambda x \to f x) y \to_\beta f y</tex>. Но если просто подставить
<tex>y</tex> в <tex>f</tex>, то получится то же самое.

{{Определение
|definition=
<tex>\eta</tex>-редукция {{---}} преобразование <tex>\lambda x \to f x</tex> в <tex>f</tex>.
}}

==Нотация Де Брюина==
Существует также альтернативное эквивалентное определение <tex>\lambda</tex>-исчисления.
В оригинальном определении для обозначения переменных использовались имена,
и была проблема с тем, что не были запрещены одинаковые имена в разных
абстракциях.

От этой проблемы можно избавиться следующим образом. Вместо имени переменной
будет храниться натуральное число {{---}} количество абстракций в дереве разбора,
на которое нужно подняться, чтобы найти ту лямбду, с которой данная переменная
связана. В данной нотации получаются несколько более простые определения
свободных переменных и <tex>\beta</tex>-редукции.

Переменная называется свободной, если ей соответствует число, которое больше
количества абстракций на пути до неё в дереве разбора.

При <tex>\beta</tex>-редукции же нужно будет ко всем свободным переменным заменяющего
дерева при каждой замене прибавить число, равное разницы уровней раньше и сейчас.
Это будет соответствовать тому, что эта переменная продолжит <<держаться>> за
ту же лямбду, что и раньше.

==Нумералы Чёрча и программирование на <tex>\lambda</tex>-исчислении==

===Определение===
Введём на основе лямбда-исчисления аналог натуральных чисел, основанный на идее,
что натуральное число {{---}} это или ноль, или увеличенное на единицу натуральное
число.

* <tex>\bar 0 = \lambda s \to \lambda z \to z</tex>
* <tex>\bar 1 = \lambda s \to \lambda z \to s z</tex>
* <tex>\bar 2 = \lambda s \to \lambda z \to s (s z)</tex>
* <tex>\bar 3 = \lambda s \to \lambda z \to s (s (s z))</tex>

Каждое число будет функцией двух аргументов: какой-то функции и начального значения.
Число <tex>n</tex> будет <tex>n</tex> раз применять функцию к начальному значению и возвращать
результат. Если такому <<числу>> дать на вход функцию <tex>(+1)</tex> и <tex>0</tex> в качестве
начального значения, то на выходе как раз будет ожидаемое от функции число:
<tex>\bar 3 (+1) 0 \equiv 3</tex>.

===+1===
Функция, прибавляющая 1 к числу, должна принимать первым аргументом число.
Но число {{---}} функция двух аргументов. Значит, эта функция должна принимать три
аргумента: <<число>> <tex>n</tex>, которое хочется увеличить, функция, которую надо будет
<tex>n+1</tex> раз применить, и начальное значение.

<tex>\operatorname{succ} = \lambda n \to \lambda s \to \lambda z \to s (n s z)</tex>

Здесь <tex>n s z</tex> {{---}} <tex>n</tex> раз применённая к <tex>z</tex> функция <tex>s</tex>. Но нужно применить <tex>n+1</tex>
раз. Отсюда <tex>s (n s z)</tex>.

===Сложение===
Сложение двух чисел похоже на прибавление единицы. Но только надо прибавить не единицу, а второе число.

<tex>\operatorname{plus} = \lambda n \to \lambda m \to \lambda s \to \lambda z \to n s (m s z)</tex>

<tex>n</tex> раз применить <tex>s</tex> к применённому <tex>m</tex> раз <tex>s</tex> к <tex>z</tex>

<tex>(\operatorname{plus} \bar 3 \bar 3) (+1) 0 \equiv 6</tex>

===Умножение===
Умножение похоже на сложение, но прибавлять надо не единицу, а второе число.
Или, в терминах нумералов Чёрча, в качестве применяемой несколько раз
функции должна быть не <tex>s</tex>, а функция, применяющая <tex>n</tex> раз <tex>s</tex>.

<tex>\operatorname{mult} = \lambda n \to \lambda m \to \lambda s \to n (m s)</tex>

Здесь <tex>m s</tex> {{---}} функция, которая <tex>m</tex> раз применит <tex>s</tex> к тому, что дадут ей на
вход. С помощью <tex>\eta</tex>-редукции можно немного сократить эту формулу

<tex>\operatorname{mult} = \lambda n \to \lambda m \to \lambda s \to n (m s)</tex>

<tex>(\operatorname{mult} \bar 3 \bar 3) (+1) 0 \equiv 9</tex>

===Возведение в степень===
It's a kind of magic

<tex>\operatorname{power} = \lambda n \to \lambda m \to m n</tex>

<tex>(\operatorname{power} \bar 3 (\operatorname{succ} \bar 3)) (+1) 0 \equiv 81</tex>

===Логические значения===
<tex>\operatorname{true} = \lambda a \to \lambda b \to a</tex>

<tex>\operatorname{false} = \lambda a \to \lambda b \to b</tex>

Функции двух аргументов, возвращающие первый и второй, соответственное, аргументы.
Забавный факт: <tex>\operatorname{false} \equiv_\alpha \operatorname{zero}$. Эти функции сделаны такими для того,
чтобы красиво написать функцию <tex>\operatorname{if}</tex>:

<tex>\operatorname{if} = \lambda p \to \lambda t \to \lambda e \to p t e</tex>

Если ей в качестве первого аргумента дадут <tex>\operatorname{true}</tex>, то вернётся <tex>t</tex>, иначе {{---}} <tex>e</tex>.

Стандартные функции булевой логики:

<tex>\operatorname{and} = \lambda n \to \lambda m \to \operatorname{if} n m \operatorname{false}</tex>

<tex>\operatorname{or} = \lambda n \to \lambda m \to \operatorname{if} n \operatorname{true} m</tex>

<tex>\opeartorname{not} = \lambda b \to \opeartorname{if} b \operatorname{false} \operatorname{true}</tex>

Ещё одной важной функцией является функция проверки, является ли число нулём:

<tex>\operatorname{isZero} = \lambda n \to n (\lambda c \to \operatorname{false}) \operatorname{true}</tex>

Функция выглядит несколько странно. <tex>\lambda c -> \operatorname{false}</tex> {{---}} функция, которая независимо
от того, что ей дали на вход, возвращает <tex>\operatorname{false}</tex>. Тогда, если в качестве <tex>n</tex>
будет дан ноль, то функция, по определению нуля, не выполнится ни разу, и будет
возвращено значение по умолчанию <tex>\operatorname{true}</tex>. Иначе же функция будет запущено, и
вернётся <tex>\operatorname{false}</tex>.

\subsection{Пара}

\begin{code}
pair' = Lam "a" $ Lam "b" $ Lam "t" $ Var "t" `App` Var "a" `App` Var "b"
fst'' = Lam "p" $ Var "p" `App` true'
snd'' = Lam "p" $ Var "p" `App` false'
\end{code}

Функция $pair$ принимает два значения и запаковывает их в пару так, чтобы к
ним можно было обращаться по $fst$ и $snd$. В $fst$ и $snd$ вместо $t$ в $pair$
будет подставлено $true$ или $false$, возвращающие, соответственно, первый и
второй аргументы, то есть $a$ или $b$, соответственно.

\subsection{Вычитание}
В отличие от всех предыдущих функций, вычитание для натуральных чисел определено
только в случае, если уменьшаемое больше вычитаемого. Положим в противном случае
результат равным нулю. Пусть уже есть функция, которая вычитает из числа единицу.
Тогда на её основе легко сделать, собственно, вычитание.

\begin{code}
minus' = Lam "n" $ Lam "m" $ Var "m" `App` pred' `App` Var "n"
\end{code}

<<$m$ раз вычесть единицу из $n$>>.

Осталось, собственно, функция для вычитания единицы. Однако, это не так просто,
как может показаться на первый взгляд. Проблема в том, что, имея функцию, которую
нужно применить для того, чтобы продвинуться вперёд, продвинуться назад будет
проблематично. Если попробовать воспользоваться идеей о том, чтобы, начав от
нуля, идти вперёд, и пройти на один шаг меньше, то будет не очень понятно, как
же остановиться ровно за один шаг до конца. Для реализации вычитания единицы
сделаем следующее. $n$ раз выполним следующее: имея пару $(n-1, n-2)$ построим пару
$(n, n-1)$. Тогда после $n$ шагов во втором элементе пары будет записано число
$n-1$, которое и хочется получить.
% --pred = \n -> \s -> \z -> n (\g -> \h -> h (g s)) (\u -> z) (\u->u)
% --pred = \n -> \s -> \z -> snd (n (\p -> (pair (s (fst p)) (fst p))) (pair z z))
% --pred = \n -> \s -> \z -> fst' (n (\p -> pair (s (fst p))(fst p)) (pair z z))

\begin{code}
pred' = Lam "n" $
Lam "s" $
Lam "z" $
snd'' `App` (Var "n"
`App` (
Lam "p" $ pair'
`App` (Var "s" `App` (fst'' `App` Var "p"))
`App` (fst'' `App` Var "p")
)
`App` ( pair' `App` Var "z" `App` Var "z" )
)
\end{code}

Если вы ничего не поняли, не огорчайтесь. Вычитание придумал Клини, когда
ему вырывали зуб мудрости. А сейчас наркоз уже не тот!

\subsection{Сравнение}
Так как вычитание определено таким способом, чтобы для случая, в котором
уменьшаемое больше, чем вычитаемое, возвращать ноль, можно определить
сравнение на больше-меньше через него. Равными же числа $a$ и $b$ считаются,
если $a - b = 0 \wedge b - a = 0$.

\begin{code}
le' = Lam "n" $ Lam "m" $ isZero' `App` (minus' `App` Var "n" `App` Var "m")
less' = Lam "n" $ Lam "m" $ le' `App` Var "n" `App` (pred' `App` Var "m")
eq' = Lam "n" $ Lam "m" $ and'
`App` (isZero' `App` (minus' `App` Var "n" `App` Var "m"))
`App` (isZero' `App` (minus' `App` Var "m" `App` Var "n"))
\end{code}

\subsection{Комбинатор неподвижной точки}
Попробуем выразить в лямбда-исчислении какую-нибудь рекурсивную функцию.
Напрмер, факториал.

\begin{spec}
fact = \x -> if (isZero x) one (fact (pred x))
\end{spec}

Мы столкнулись с проблемой. В определении функции $fact$ используется функция
$fact$. При формальной замене, получим бесконечную функцию. Можно попытаться решить
эту проблему следующим образом

\begin{spec}
fact = (\f -> \x -> if (isZero x) one (f (pred x))) fact
\end{spec}

\emph{Неподвижной точкой} лямбда-функции $f$ назовём такую функцию $x$, что
$f x \to_\beta x$. Лямбда исчисление обладаем замечательным свойством: у каждой
функции есть неподвижная точка!

Рассмотрим такую функцию.

\begin{code}
fix' = Lam "f" $ (Lam "x" $ Var "f" `App` (Var "x" `App` Var "x"))
`App` (Lam "x" $ Var "f" `App` (Var "x" `App` Var "x"))
\end{code}

Заметим, что $fix' \to_\beta \lambda f \to f ((\lambda x \to f (x x)) (\lambda x \to f (x x)))$.
Или, что то же самое,
$\lambda f \to (\lambda x \to f (x x)) (\lambda x \to f (x x)) \to_\beta
\lambda f \to f ((\lambda x \to f (x x)) (\lambda x \to f (x x)))$

Рассмотрим функцию

\begin{code}
fact'' = Lam "f" $ Lam "x" $ if'' `App` (isZero' `App` Var "x")
`App` one'
`App` (mult' `App` Var "x" `App` (Var "f" `App`
(pred' `App` Var "x")))
\end{code}

Как было показано выше, $fix f \to_\beta f (fix f)$, то есть,
$fix fact'' \to_\beta fact'$, где $fact'$~--- искомая функция, считающая факториал.

\begin{code}
fact' = fix' `App` fact''
\end{code}

Это даст функцию, которая посчитает факториал числа. Но делать она это будет
мееедленно-меееедленно. Для того, чтобы посчитать $5!$ потребовалось сделать
66066 $\beta$-редукций.

Тут правда ничего не понятно? :'(

\subsection{Деление}
Воспользовавшись идеей о том, что можно делать рекурсивные функции, сделаем
функцию, которая будет искать частное двух чисел.

\begin{code}
div'' = Lam "div" $ Lam "n" $ Lam "m" $ if'' `App` (less' `App` Var "n" `App` Var "m")
`App` zero'
`App` (succ' `App` (Var "div" `App` (minus' `App` Var "n" `App` Var "m") `App` Var "m"))
div' = fix' `App` div''
\end{code}

И остатка от деления

\begin{code}
mod'' = Lam "mod" $ Lam "n" $ Lam "m" $ if'' `App` (less' `App` Var "n" `App` Var "m")
`App` Var "n"
`App` (Var "mod" `App` (minus' `App` Var "n" `App` Var "m") `App` Var "m")
mod' = fix' `App` mod'';
\end{code}

\subsection{Проверка на простоту}

$isPrimeHelp$~--- принимает число, которое требуется проверить на простоту и
то, на что его надо попытаться поделить, перебирая это от 2 до $p-1$. Если на
что-нибудь разделилось, то число~--- составное, иначе~--- простое.

\begin{code}
isPrimeHelp' = Lam "f" $ Lam "p" $ Lam "i" $ if'' `App` (le' `App` Var "p" `App` Var "i")
`App` true'
`App` ( if'' `App` (isZero' `App` (mod' `App` Var "p" `App` Var "i"))
`App` false'
`App` (Var "f" `App` Var "p" `App` (succ' `App` Var "i"))
)
isPrimeHelp = fix' `App` isPrimeHelp'
isPrime = Lam "p" $ isPrimeHelp `App` Var "p" `App` two'
\end{code}

Следующее простое число. $nextPrime'$~--- следующее, больше либо равное заданного,
$nextPrime$~--- следующее, большее заданного.

\begin{code}
nextPrime'' = Lam "f" $ Lam "p" $ if'' `App` (isPrime `App` Var "p")
`App` Var "p"
`App` (Var "f" `App` (succ' `App` Var "p"))
nextPrime' = fix' `App` nextPrime''
nextPrime = Lam "p" $ nextPrime' `App` (succ' `App` Var "p")
\end{code}

$ithPrimeStep$ пропрыгает $i$ простых чисел вперёд. $ithPrime$ принимает число
$i$ и пропрыгивает столько простых чисел вперёд, начиная с двойки.

\begin{code}
ithPrimeStep' = Lam "f" $ Lam "p" $ Lam "i" $ if'' `App` (isZero' `App` Var "i")
`App` Var "p"
`App` (Var "f" `App` (nextPrime `App` Var "p") `App` (pred' `App` Var "i"))
ithPrimeStep = fix' `App` ithPrimeStep'
ithPrime = Lam "i" $ ithPrimeStep `App` two' `App` Var "i"
\end{code}

...и всего через 314007 $\beta$-редукций вы узнаете, что третье простое число~---
семь!

\subsection{Списки}

Для работы со списками чисел нам понадобятся следующие функции:
\begin{itemize}
\item $empty$~--- возвращает пустой список
\item $cons$~--- принимает первый элемент и оставшийся список, склеивает их
\item $head$~--- вернуть голову списка
\item $tail$~--- вернуть хвост списка
\end{itemize}

Список будем хранить в следующем виде: $\langle len, p_1^{a_1}p_2^{a_2}\ldots p_{len}^{a_{len}} \rangle$. При этом, голова списка будет храниться как показатель степени при $p_{len}$.

\begin{code}
empty = pair' `App` zero' `App` one'
cons = Lam "h" $ Lam "t" $ pair' `App` (succ' `App` (fst'' `App` Var "t"))
`App` (mult' `App` (snd'' `App` Var "t") `App` (power'
`App` (ithPrime `App` (fst'' `App` Var "t"))
`App` Var "h"
))
head = Lam "list" $ getExponent `App` (snd'' `App` Var "list")
`App` (ithPrime `App` (pred' `App` (fst'' `App` Var "list")))

tail = Lam "list" $ pair' `App` (pred' `App` (fst'' `App` Var "list"))
`App` (eliminateMultiplier `App` (snd'' `App` Var "list")
`App` (ithPrime `App` (pred' `App` (fst'' `App` Var "list" )))
)

eliminateMultiplier' = Lam "f" $ Lam "n" $ Lam "m" $ if'' `App` (isZero' `App` (mod' `App` Var "n" `App` Var "m"))
`App` (Var "f" `App` (div' `App` Var "n" `App` Var "m") `App` Var "m")
`App` Var "n"
eliminateMultiplier = fix' `App` eliminateMultiplier'

getExponent' = Lam "f" $ Lam "n" $ Lam "m" $ if'' `App` (isZero' `App` (mod' `App` Var "n" `App` Var "m"))
`App` (succ' `App`(Var "f" `App` (div' `App` Var "n" `App` Var "m") `App` Var "m"))
`App` zero'
getExponent = fix' `App` getExponent'
\end{code}

На основе этого всего уже можно реализовать эмулятор машины тьюринга:
с помощью пар, списков чисел можно хранить состояния. С помощью рекурсии можно
обрабатывать переходы. Входная строка будет даваться, например, закодированной
аналогично списку: пара из длины и числа, характеризующего список степенями
простых. Я бы продолжил это писать, но уже на операции $head [1, 2]$ я не
дождался окончания выполнения. Скорость лямбда-исчисления как вычислителя
печальна.

\ignore{
\begin{code}

four' = norm $ succ' `App` three'
five' = norm $ succ' `App` four'

list2 = norm $ cons `App` one' `App` empty
list32 = cons `App` zero' `App` list2

normFiveFact = normIO 0 $ fact' `App` five'

-- fiftysix = mult twentyeight two
-- fiftyfive = pred fiftysix
-- six = pred seven

--main = do print $ fiftysix (+1) 0
main = do
-- f <- normIO 0 $ ithPrime `App` three'
-- f <- normIO 0 $ getExponent `App` (norm $ plus' `App` four' `App` four') `App` two'
f <- normIO 0 $ head `App` (tail `App` list32)
print $ toInt f
\end{code}
}

\end{document}
[http://rain.ifmo.ru/~komarov/Turing.lhs]

Поиск наибольшей общей подстроки двух строк с использованием хеширования

2012-09-12T14:00:39Z

194.85.160.130: /* Псевдокод */

==Постановка задачи==
Имеются строки <tex>s</tex> и <tex>t</tex> такие, что элементы этих строк <tex>-</tex> символы из конечного алфавита <tex> \Sigma </tex>. Говорят, что строка <tex>z[1 .. m]</tex> является подстрокой строки <tex>s[1 .. n]</tex>, если существует такой индекс <tex>k \in [0 .. n - m]</tex>, что для любого <tex>i \in [1 .. m]</tex> справедливо <tex>s[k + i] = z[i]</tex>. Требуется найти такую строку <tex>z</tex> максимальной длины, что <tex>z</tex> является и подстрокой <tex>s</tex>, и подстрокой <tex>t</tex>.

==Алгоритм==
Пусть длина наибольшей общей подстроки будет <tex>x</tex>. Заметим, что у строк <tex>s</tex> и <tex>t</tex> обязательно найдется общая подстрока длины <tex>y \in [0 .. x]</tex>, так как в качестве такой строки можно взять префикс наибольшей общей подстроки. Рассмотрим функцию <tex>f : [0 .. \min(|s|, |t|)] \rightarrow \{0, 1\}</tex>, которая для <tex>i</tex> из области определения равна 1, если у строк <tex>s</tex> и <tex>t</tex> есть общая подстрока длины <tex>i</tex>, иначе она равна 0. Согласно замечанию, функция <tex>f</tex> должна по мере возрастания <tex>i</tex> быть равной 1 до некоторого момента, а затем обращаться в 0. Собственно, максимальное значение, при котором функция принимает значение 1, является длиной наибольшей общей подстроки. Таким образом, требуется с помощью [[Целочисленный двоичный поиск|двоичного поиска]] найти это значение. В ходе работы придется проверять наличие общей подстроки заданной длины. Для этого будем использовать хеширование, чтобы улучшить асимптотику алгоритма. Алгоритм является эвристическим и может выдавать неверный ответ, так как совпадение хешей строк не гарантирует равенство строк. Поэтому нужно выполнить проверку нескольких случайных символов подстрок на совпадение, проиграв при этом по времени работы. Алгоритм работает следующим образом:

1) У строки <tex>s</tex> хешируем подстроки заданной длины и полученные хеши записываем в Set.

2) У строки <tex>t</tex> хешируем подстроки заданной длины и в случае совпадения хеша с элементом Set проверяем несколько случайных символов подстрок на совпадение.

Хеширование будем производить так же, как и в [[Поиск подстроки в строке с использованием хеширования. Алгоритм Рабина-Карпа|алгоритме Рабина-Карпа]].

== Псевдокод ==

<tex>f</tex> — функция, описанная в алгоритме.

<tex>i</tex> — длина подстроки, найденная с помощью [[Целочисленный двоичный поиск|двоичного поиска]].

<tex>f(i)</tex>
Записываем в <tex>S</tex> хеши подстрок строки <tex>s</tex> длины <tex>i</tex>;
'''for''' <tex>j = 1...|t| - i + 1</tex>
Считаем хеш от подстроки <tex>t[j .. j + i - 1]</tex>;
'''if''' хеш содержится в <tex>S</tex>
'''if''' совпали несколько случайных символов подстрок
'''return''' 1;
'''else'''
'''continue''';
'''return''' 0;

==Время работы==
Проведем оценку асимптотики времени работы предложенного алгоритма. Посмотрим сколько нам потребуется действий на каждом шаге бинарного поиска. Во-первых, хеширование подстрок строки <tex>s</tex> и запись их в Set требует <tex>O(|s|)</tex> шагов. Во-вторых, хеширование подстрок строки <tex>t</tex> и проверка их наличия в Set требует <tex>O(|t|)</tex>. Проверка на совпадение нескольких символов подстрок требует константное время. Значит,на каждый шаг бинарного поиска требуется <tex>O(max(|s|, |t|))</tex> действий. Заметим, что всего для завершения бинарного поиска потребуется <tex>O(\log(\min(|s|, |t|)))</tex> шагов. Следовательно, суммарное время работы алгоритма будет <tex>O(\log(\min(|s|, |t|)) \cdot \max(|s|, |t|))</tex> действий.

== Литература ==
* Кормен Т., Лейзерсон Ч., Ривест Р. Алгоритмы: построение и анализ. — 2-е изд. — М.: Издательский дом «Вильямс», 2007. — С. 1296.

[[Категория:Алгоритмы и структуры данных]]
[[Категория:Поиск подстроки в строке]]

Поиск наибольшей общей подстроки двух строк с использованием хеширования

2012-09-12T13:56:59Z

194.85.160.130: /* Псевдокод */

Поиск наибольшей общей подстроки двух строк с использованием хеширования

2012-09-12T13:52:14Z

194.85.160.130: /* Псевдокод */

==Постановка задачи==
Имеются строки <tex>s</tex> и <tex>t</tex> такие, что элементы этих строк <tex>-</tex> символы из конечного алфавита <tex> \Sigma </tex>. Говорят, что строка <tex>z[1 .. m]</tex> является подстрокой строки <tex>s[1 .. n]</tex>, если существует такой индекс <tex>k \in [0 .. n - m]</tex>, что для любого <tex>i \in [1 .. m]</tex> справедливо <tex>s[k + i] = z[i]</tex>. Требуется найти такую строку <tex>z</tex> максимальной длины, что <tex>z</tex> является и подстрокой <tex>s</tex>, и подстрокой <tex>t</tex>.

==Алгоритм==
Пусть длина наибольшей общей подстроки будет <tex>x</tex>. Заметим, что у строк <tex>s</tex> и <tex>t</tex> обязательно найдется общая подстрока длины <tex>y \in [0 .. x]</tex>, так как в качестве такой строки можно взять префикс наибольшей общей подстроки. Рассмотрим функцию <tex>f : [0 .. \min(|s|, |t|)] \rightarrow \{0, 1\}</tex>, которая для <tex>i</tex> из области определения равна 1, если у строк <tex>s</tex> и <tex>t</tex> есть общая подстрока длины <tex>i</tex>, иначе она равна 0. Согласно замечанию, функция <tex>f</tex> должна по мере возрастания <tex>i</tex> быть равной 1 до некоторого момента, а затем обращаться в 0. Собственно, максимальное значение, при котором функция принимает значение 1, является длиной наибольшей общей подстроки. Таким образом, требуется с помощью [[Целочисленный двоичный поиск|двоичного поиска]] найти это значение. В ходе работы придется проверять наличие общей подстроки заданной длины. Для этого будем использовать хеширование, чтобы улучшить асимптотику алгоритма. Алгоритм является эвристическим и может выдавать неверный ответ, так как совпадение хешей строк не гарантирует равенство строк. Поэтому нужно выполнить проверку нескольких случайных символов подстрок на совпадение, проиграв при этом по времени работы. Алгоритм работает следующим образом:

1) У строки <tex>s</tex> хешируем подстроки заданной длины и полученные хеши записываем в Set.

2) У строки <tex>t</tex> хешируем подстроки заданной длины и в случае совпадения хеша с элементом Set проверяем несколько случайных символов подстрок на совпадение.

Хеширование будем производить так же, как и в [[Поиск подстроки в строке с использованием хеширования. Алгоритм Рабина-Карпа|алгоритме Рабина-Карпа]].

== Псевдокод ==

<tex>f</tex> — функция, описанная в алгоритме.

<tex>i</tex> — длина подстроки, найденная с помощью [[Целочисленный двоичный поиск|двоичного поиска]].

<tex>f(i)</tex>
Записываем в <tex>S</tex> хеши подстрок строки <tex>s</tex> длины <tex>i</tex>;
'''for''' <tex>j = 1...|t| - i + 1</tex>
Считаем хеш от подстоки <tex>t[j .. j + i - 1]</tex>;
'''if''' хеш содержится в <tex>S</tex>
'''if''' совпали несколько случайных символов подстрок
'''return''' 1;
'''else'''
'''continue''';
'''return''' 0;

==Время работы==
Проведем оценку асимптотики времени работы предложенного алгоритма. Посмотрим сколько нам потребуется действий на каждом шаге бинарного поиска. Во-первых, хеширование подстрок строки <tex>s</tex> и запись их в Set требует <tex>O(|s|)</tex> шагов. Во-вторых, хеширование подстрок строки <tex>t</tex> и проверка их наличия в Set требует <tex>O(|t|)</tex>. Проверка на совпадение нескольких символов подстрок требует константное время. Значит,на каждый шаг бинарного поиска требуется <tex>O(max(|s|, |t|))</tex> действий. Заметим, что всего для завершения бинарного поиска потребуется <tex>O(\log(\min(|s|, |t|)))</tex> шагов. Следовательно, суммарное время работы алгоритма будет <tex>O(\log(\min(|s|, |t|)) \cdot \max(|s|, |t|))</tex> действий.

== Литература ==
* Кормен Т., Лейзерсон Ч., Ривест Р. Алгоритмы: построение и анализ. — 2-е изд. — М.: Издательский дом «Вильямс», 2007. — С. 1296.

[[Категория:Алгоритмы и структуры данных]]
[[Категория:Поиск подстроки в строке]]

Поиск наибольшей общей подстроки двух строк с использованием хеширования

2012-09-12T13:51:42Z

194.85.160.130: /* Псевдокод */

==Постановка задачи==
Имеются строки <tex>s</tex> и <tex>t</tex> такие, что элементы этих строк <tex>-</tex> символы из конечного алфавита <tex> \Sigma </tex>. Говорят, что строка <tex>z[1 .. m]</tex> является подстрокой строки <tex>s[1 .. n]</tex>, если существует такой индекс <tex>k \in [0 .. n - m]</tex>, что для любого <tex>i \in [1 .. m]</tex> справедливо <tex>s[k + i] = z[i]</tex>. Требуется найти такую строку <tex>z</tex> максимальной длины, что <tex>z</tex> является и подстрокой <tex>s</tex>, и подстрокой <tex>t</tex>.

==Алгоритм==
Пусть длина наибольшей общей подстроки будет <tex>x</tex>. Заметим, что у строк <tex>s</tex> и <tex>t</tex> обязательно найдется общая подстрока длины <tex>y \in [0 .. x]</tex>, так как в качестве такой строки можно взять префикс наибольшей общей подстроки. Рассмотрим функцию <tex>f : [0 .. \min(|s|, |t|)] \rightarrow \{0, 1\}</tex>, которая для <tex>i</tex> из области определения равна 1, если у строк <tex>s</tex> и <tex>t</tex> есть общая подстрока длины <tex>i</tex>, иначе она равна 0. Согласно замечанию, функция <tex>f</tex> должна по мере возрастания <tex>i</tex> быть равной 1 до некоторого момента, а затем обращаться в 0. Собственно, максимальное значение, при котором функция принимает значение 1, является длиной наибольшей общей подстроки. Таким образом, требуется с помощью [[Целочисленный двоичный поиск|двоичного поиска]] найти это значение. В ходе работы придется проверять наличие общей подстроки заданной длины. Для этого будем использовать хеширование, чтобы улучшить асимптотику алгоритма. Алгоритм является эвристическим и может выдавать неверный ответ, так как совпадение хешей строк не гарантирует равенство строк. Поэтому нужно выполнить проверку нескольких случайных символов подстрок на совпадение, проиграв при этом по времени работы. Алгоритм работает следующим образом:

1) У строки <tex>s</tex> хешируем подстроки заданной длины и полученные хеши записываем в Set.

2) У строки <tex>t</tex> хешируем подстроки заданной длины и в случае совпадения хеша с элементом Set проверяем несколько случайных символов подстрок на совпадение.

Хеширование будем производить так же, как и в [[Поиск подстроки в строке с использованием хеширования. Алгоритм Рабина-Карпа|алгоритме Рабина-Карпа]].

== Псевдокод ==

<tex>f</tex> — функция, описанная в алгоритме.

<tex>i</tex> — длина подстроки, найденная с помощью [[Целочисленный двоичный поиск|двоичного поиска]].

<tex>f(i)</tex>
Записываем в <tex>S</tex> хеши подстрок строки <tex>s</tex> длины <tex>i</tex>;
'''for''' <tex>j = 1...|t| - i + 1</tex>
Считаем хеш от подстоки <tex>t[j .. j + i - 1]</tex>;
'''if''' хеш содержится в <tex>S</tex>
'''if''' совпали несколько случайных символов подстрок
'''return''' 1;
'''else'''
'''continue''';
'''return''' 0;

==Время работы==
Проведем оценку асимптотики времени работы предложенного алгоритма. Посмотрим сколько нам потребуется действий на каждом шаге бинарного поиска. Во-первых, хеширование подстрок строки <tex>s</tex> и запись их в Set требует <tex>O(|s|)</tex> шагов. Во-вторых, хеширование подстрок строки <tex>t</tex> и проверка их наличия в Set требует <tex>O(|t|)</tex>. Проверка на совпадение нескольких символов подстрок требует константное время. Значит,на каждый шаг бинарного поиска требуется <tex>O(max(|s|, |t|))</tex> действий. Заметим, что всего для завершения бинарного поиска потребуется <tex>O(\log(\min(|s|, |t|)))</tex> шагов. Следовательно, суммарное время работы алгоритма будет <tex>O(\log(\min(|s|, |t|)) \cdot \max(|s|, |t|))</tex> действий.

== Литература ==
* Кормен Т., Лейзерсон Ч., Ривест Р. Алгоритмы: построение и анализ. — 2-е изд. — М.: Издательский дом «Вильямс», 2007. — С. 1296.

[[Категория:Алгоритмы и структуры данных]]
[[Категория:Поиск подстроки в строке]]

Поиск наибольшей общей подстроки двух строк с использованием хеширования

2012-09-12T13:48:01Z

194.85.160.130: /* Псевдокод */

==Постановка задачи==
Имеются строки <tex>s</tex> и <tex>t</tex> такие, что элементы этих строк <tex>-</tex> символы из конечного алфавита <tex> \Sigma </tex>. Говорят, что строка <tex>z[1 .. m]</tex> является подстрокой строки <tex>s[1 .. n]</tex>, если существует такой индекс <tex>k \in [0 .. n - m]</tex>, что для любого <tex>i \in [1 .. m]</tex> справедливо <tex>s[k + i] = z[i]</tex>. Требуется найти такую строку <tex>z</tex> максимальной длины, что <tex>z</tex> является и подстрокой <tex>s</tex>, и подстрокой <tex>t</tex>.

==Алгоритм==
Пусть длина наибольшей общей подстроки будет <tex>x</tex>. Заметим, что у строк <tex>s</tex> и <tex>t</tex> обязательно найдется общая подстрока длины <tex>y \in [0 .. x]</tex>, так как в качестве такой строки можно взять префикс наибольшей общей подстроки. Рассмотрим функцию <tex>f : [0 .. \min(|s|, |t|)] \rightarrow \{0, 1\}</tex>, которая для <tex>i</tex> из области определения равна 1, если у строк <tex>s</tex> и <tex>t</tex> есть общая подстрока длины <tex>i</tex>, иначе она равна 0. Согласно замечанию, функция <tex>f</tex> должна по мере возрастания <tex>i</tex> быть равной 1 до некоторого момента, а затем обращаться в 0. Собственно, максимальное значение, при котором функция принимает значение 1, является длиной наибольшей общей подстроки. Таким образом, требуется с помощью [[Целочисленный двоичный поиск|двоичного поиска]] найти это значение. В ходе работы придется проверять наличие общей подстроки заданной длины. Для этого будем использовать хеширование, чтобы улучшить асимптотику алгоритма. Алгоритм является эвристическим и может выдавать неверный ответ, так как совпадение хешей строк не гарантирует равенство строк. Поэтому нужно выполнить проверку нескольких случайных символов подстрок на совпадение, проиграв при этом по времени работы. Алгоритм работает следующим образом:

1) У строки <tex>s</tex> хешируем подстроки заданной длины и полученные хеши записываем в Set.

2) У строки <tex>t</tex> хешируем подстроки заданной длины и в случае совпадения хеша с элементом Set проверяем несколько случайных символов подстрок на совпадение.

Хеширование будем производить так же, как и в [[Поиск подстроки в строке с использованием хеширования. Алгоритм Рабина-Карпа|алгоритме Рабина-Карпа]].

== Псевдокод ==

<tex>f</tex> — функция, описанная в алгоритме.

<tex>i</tex> — длина подстроки, найденная с помощью [[Целочисленный двоичный поиск|двоичного поиска]].

<tex>f(i)</tex>
Записываем в <tex>S</tex> хеши подстрок строки <tex>s</tex> длины <tex>i</tex>;
'''for''' <tex>j = 1...|t| - i + 1</tex>
Считаем хеш от подстоки <tex>t[j .. j + i - 1]</tex>;
'''if''' хеш содержится в <tex>S</tex>
'''if''' совпали несколько случайных символов подстрок
'''return''' 1;
'''else'''
'''continue''';
'''return''' 0;

==Время работы==
Проведем оценку асимптотики времени работы предложенного алгоритма. Посмотрим сколько нам потребуется действий на каждом шаге бинарного поиска. Во-первых, хеширование подстрок строки <tex>s</tex> и запись их в Set требует <tex>O(|s|)</tex> шагов. Во-вторых, хеширование подстрок строки <tex>t</tex> и проверка их наличия в Set требует <tex>O(|t|)</tex>. Проверка на совпадение нескольких символов подстрок требует константное время. Значит,на каждый шаг бинарного поиска требуется <tex>O(max(|s|, |t|))</tex> действий. Заметим, что всего для завершения бинарного поиска потребуется <tex>O(\log(\min(|s|, |t|)))</tex> шагов. Следовательно, суммарное время работы алгоритма будет <tex>O(\log(\min(|s|, |t|)) \cdot \max(|s|, |t|))</tex> действий.

== Литература ==
* Кормен Т., Лейзерсон Ч., Ривест Р. Алгоритмы: построение и анализ. — 2-е изд. — М.: Издательский дом «Вильямс», 2007. — С. 1296.

[[Категория:Алгоритмы и структуры данных]]
[[Категория:Поиск подстроки в строке]]

Поиск наибольшей общей подстроки двух строк с использованием хеширования

2012-09-12T13:41:36Z

194.85.160.130: /* Псевдокод */

==Постановка задачи==
Имеются строки <tex>s</tex> и <tex>t</tex> такие, что элементы этих строк <tex>-</tex> символы из конечного алфавита <tex> \Sigma </tex>. Говорят, что строка <tex>z[1 .. m]</tex> является подстрокой строки <tex>s[1 .. n]</tex>, если существует такой индекс <tex>k \in [0 .. n - m]</tex>, что для любого <tex>i \in [1 .. m]</tex> справедливо <tex>s[k + i] = z[i]</tex>. Требуется найти такую строку <tex>z</tex> максимальной длины, что <tex>z</tex> является и подстрокой <tex>s</tex>, и подстрокой <tex>t</tex>.

==Алгоритм==
Пусть длина наибольшей общей подстроки будет <tex>x</tex>. Заметим, что у строк <tex>s</tex> и <tex>t</tex> обязательно найдется общая подстрока длины <tex>y \in [0 .. x]</tex>, так как в качестве такой строки можно взять префикс наибольшей общей подстроки. Рассмотрим функцию <tex>f : [0 .. \min(|s|, |t|)] \rightarrow \{0, 1\}</tex>, которая для <tex>i</tex> из области определения равна 1, если у строк <tex>s</tex> и <tex>t</tex> есть общая подстрока длины <tex>i</tex>, иначе она равна 0. Согласно замечанию, функция <tex>f</tex> должна по мере возрастания <tex>i</tex> быть равной 1 до некоторого момента, а затем обращаться в 0. Собственно, максимальное значение, при котором функция принимает значение 1, является длиной наибольшей общей подстроки. Таким образом, требуется с помощью [[Целочисленный двоичный поиск|двоичного поиска]] найти это значение. В ходе работы придется проверять наличие общей подстроки заданной длины. Для этого будем использовать хеширование, чтобы улучшить асимптотику алгоритма. Алгоритм является эвристическим и может выдавать неверный ответ, так как совпадение хешей строк не гарантирует равенство строк. Поэтому нужно выполнить проверку нескольких случайных символов подстрок на совпадение, проиграв при этом по времени работы. Алгоритм работает следующим образом:

1) У строки <tex>s</tex> хешируем подстроки заданной длины и полученные хеши записываем в Set.

2) У строки <tex>t</tex> хешируем подстроки заданной длины и в случае совпадения хеша с элементом Set проверяем несколько случайных символов подстрок на совпадение.

Хеширование будем производить так же, как и в [[Поиск подстроки в строке с использованием хеширования. Алгоритм Рабина-Карпа|алгоритме Рабина-Карпа]].

== Псевдокод ==

<tex>f</tex> — функция, описанная в алгоритме.

<tex>i</tex> — длина подстроки, найденная с помощью [[Целочисленный двоичный поиск|двоичного поиска]].

<tex>f(i)</tex>
Записываем в <tex>S</tex> хэши подстрок строки <tex>s</tex> длины <tex>i</tex>;
'''for''' <tex>j = 1...|t| - i + 1</tex>
Считаем хэш от подстоки <tex>t[j .. j + i - 1]</tex>;
'''if''' хэш содержится в <tex>S</tex>
'''if''' совпали несколько случайных символов подсток
return 1;
'''else'''
continue;
return 0;

==Время работы==
Проведем оценку асимптотики времени работы предложенного алгоритма. Посмотрим сколько нам потребуется действий на каждом шаге бинарного поиска. Во-первых, хеширование подстрок строки <tex>s</tex> и запись их в Set требует <tex>O(|s|)</tex> шагов. Во-вторых, хеширование подстрок строки <tex>t</tex> и проверка их наличия в Set требует <tex>O(|t|)</tex>. Проверка на совпадение нескольких символов подстрок требует константное время. Значит,на каждый шаг бинарного поиска требуется <tex>O(max(|s|, |t|))</tex> действий. Заметим, что всего для завершения бинарного поиска потребуется <tex>O(\log(\min(|s|, |t|)))</tex> шагов. Следовательно, суммарное время работы алгоритма будет <tex>O(\log(\min(|s|, |t|)) \cdot \max(|s|, |t|))</tex> действий.

== Литература ==
* Кормен Т., Лейзерсон Ч., Ривест Р. Алгоритмы: построение и анализ. — 2-е изд. — М.: Издательский дом «Вильямс», 2007. — С. 1296.

[[Категория:Алгоритмы и структуры данных]]
[[Категория:Поиск подстроки в строке]]

Поиск наибольшей общей подстроки двух строк с использованием хеширования

2012-09-12T13:40:00Z

194.85.160.130: /* Псевдокод */

==Постановка задачи==
Имеются строки <tex>s</tex> и <tex>t</tex> такие, что элементы этих строк <tex>-</tex> символы из конечного алфавита <tex> \Sigma </tex>. Говорят, что строка <tex>z[1 .. m]</tex> является подстрокой строки <tex>s[1 .. n]</tex>, если существует такой индекс <tex>k \in [0 .. n - m]</tex>, что для любого <tex>i \in [1 .. m]</tex> справедливо <tex>s[k + i] = z[i]</tex>. Требуется найти такую строку <tex>z</tex> максимальной длины, что <tex>z</tex> является и подстрокой <tex>s</tex>, и подстрокой <tex>t</tex>.

==Алгоритм==
Пусть длина наибольшей общей подстроки будет <tex>x</tex>. Заметим, что у строк <tex>s</tex> и <tex>t</tex> обязательно найдется общая подстрока длины <tex>y \in [0 .. x]</tex>, так как в качестве такой строки можно взять префикс наибольшей общей подстроки. Рассмотрим функцию <tex>f : [0 .. \min(|s|, |t|)] \rightarrow \{0, 1\}</tex>, которая для <tex>i</tex> из области определения равна 1, если у строк <tex>s</tex> и <tex>t</tex> есть общая подстрока длины <tex>i</tex>, иначе она равна 0. Согласно замечанию, функция <tex>f</tex> должна по мере возрастания <tex>i</tex> быть равной 1 до некоторого момента, а затем обращаться в 0. Собственно, максимальное значение, при котором функция принимает значение 1, является длиной наибольшей общей подстроки. Таким образом, требуется с помощью [[Целочисленный двоичный поиск|двоичного поиска]] найти это значение. В ходе работы придется проверять наличие общей подстроки заданной длины. Для этого будем использовать хеширование, чтобы улучшить асимптотику алгоритма. Алгоритм является эвристическим и может выдавать неверный ответ, так как совпадение хешей строк не гарантирует равенство строк. Поэтому нужно выполнить проверку нескольких случайных символов подстрок на совпадение, проиграв при этом по времени работы. Алгоритм работает следующим образом:

1) У строки <tex>s</tex> хешируем подстроки заданной длины и полученные хеши записываем в Set.

2) У строки <tex>t</tex> хешируем подстроки заданной длины и в случае совпадения хеша с элементом Set проверяем несколько случайных символов подстрок на совпадение.

Хеширование будем производить так же, как и в [[Поиск подстроки в строке с использованием хеширования. Алгоритм Рабина-Карпа|алгоритме Рабина-Карпа]].

== Псевдокод ==

<tex>f</tex> — функция, описанная в алгоритме.

<tex>i</tex> — длина подстроки, найденная с помощью [[Целочисленный двоичный поиск|двоичного поиска]].

<tex>f(i)</tex>
Записываем в <tex>S</tex> хэши подстрок строки <tex>s</tex> длины <tex>i</tex>;
'''for''' <tex>j = 1...|t| - i</tex>
Считаем хэш от подстоки <tex>t[j .. j + i]</tex>;
'''if''' хэш содержится в <tex>S</tex>
'''if''' совпали несколько случайных символов подсток
return 1;
'''else'''
continue;
return 0;

==Время работы==
Проведем оценку асимптотики времени работы предложенного алгоритма. Посмотрим сколько нам потребуется действий на каждом шаге бинарного поиска. Во-первых, хеширование подстрок строки <tex>s</tex> и запись их в Set требует <tex>O(|s|)</tex> шагов. Во-вторых, хеширование подстрок строки <tex>t</tex> и проверка их наличия в Set требует <tex>O(|t|)</tex>. Проверка на совпадение нескольких символов подстрок требует константное время. Значит,на каждый шаг бинарного поиска требуется <tex>O(max(|s|, |t|))</tex> действий. Заметим, что всего для завершения бинарного поиска потребуется <tex>O(\log(\min(|s|, |t|)))</tex> шагов. Следовательно, суммарное время работы алгоритма будет <tex>O(\log(\min(|s|, |t|)) \cdot \max(|s|, |t|))</tex> действий.

== Литература ==
* Кормен Т., Лейзерсон Ч., Ривест Р. Алгоритмы: построение и анализ. — 2-е изд. — М.: Издательский дом «Вильямс», 2007. — С. 1296.

[[Категория:Алгоритмы и структуры данных]]
[[Категория:Поиск подстроки в строке]]

Поиск наибольшей общей подстроки двух строк с использованием хеширования

2012-09-12T13:39:42Z

194.85.160.130: /* Псевдокод */

==Постановка задачи==
Имеются строки <tex>s</tex> и <tex>t</tex> такие, что элементы этих строк <tex>-</tex> символы из конечного алфавита <tex> \Sigma </tex>. Говорят, что строка <tex>z[1 .. m]</tex> является подстрокой строки <tex>s[1 .. n]</tex>, если существует такой индекс <tex>k \in [0 .. n - m]</tex>, что для любого <tex>i \in [1 .. m]</tex> справедливо <tex>s[k + i] = z[i]</tex>. Требуется найти такую строку <tex>z</tex> максимальной длины, что <tex>z</tex> является и подстрокой <tex>s</tex>, и подстрокой <tex>t</tex>.

==Алгоритм==
Пусть длина наибольшей общей подстроки будет <tex>x</tex>. Заметим, что у строк <tex>s</tex> и <tex>t</tex> обязательно найдется общая подстрока длины <tex>y \in [0 .. x]</tex>, так как в качестве такой строки можно взять префикс наибольшей общей подстроки. Рассмотрим функцию <tex>f : [0 .. \min(|s|, |t|)] \rightarrow \{0, 1\}</tex>, которая для <tex>i</tex> из области определения равна 1, если у строк <tex>s</tex> и <tex>t</tex> есть общая подстрока длины <tex>i</tex>, иначе она равна 0. Согласно замечанию, функция <tex>f</tex> должна по мере возрастания <tex>i</tex> быть равной 1 до некоторого момента, а затем обращаться в 0. Собственно, максимальное значение, при котором функция принимает значение 1, является длиной наибольшей общей подстроки. Таким образом, требуется с помощью [[Целочисленный двоичный поиск|двоичного поиска]] найти это значение. В ходе работы придется проверять наличие общей подстроки заданной длины. Для этого будем использовать хеширование, чтобы улучшить асимптотику алгоритма. Алгоритм является эвристическим и может выдавать неверный ответ, так как совпадение хешей строк не гарантирует равенство строк. Поэтому нужно выполнить проверку нескольких случайных символов подстрок на совпадение, проиграв при этом по времени работы. Алгоритм работает следующим образом:

1) У строки <tex>s</tex> хешируем подстроки заданной длины и полученные хеши записываем в Set.

2) У строки <tex>t</tex> хешируем подстроки заданной длины и в случае совпадения хеша с элементом Set проверяем несколько случайных символов подстрок на совпадение.

Хеширование будем производить так же, как и в [[Поиск подстроки в строке с использованием хеширования. Алгоритм Рабина-Карпа|алгоритме Рабина-Карпа]].

== Псевдокод ==

<tex>f</tex> — функция, описанная в алгоритме.

<tex>i</tex> - длина подстроки, найденная с помощью [[Целочисленный двоичный поиск|двоичного поиска]].

<tex>f(i)</tex>
Записываем в <tex>S</tex> хэши подстрок строки <tex>s</tex> длины <tex>i</tex>;
'''for''' <tex>j = 1...|t| - i</tex>
Считаем хэш от подстоки <tex>t[j .. j + i]</tex>;
'''if''' хэш содержится в <tex>S</tex>
'''if''' совпали несколько случайных символов подсток
return 1;
'''else'''
continue;
return 0;

==Время работы==
Проведем оценку асимптотики времени работы предложенного алгоритма. Посмотрим сколько нам потребуется действий на каждом шаге бинарного поиска. Во-первых, хеширование подстрок строки <tex>s</tex> и запись их в Set требует <tex>O(|s|)</tex> шагов. Во-вторых, хеширование подстрок строки <tex>t</tex> и проверка их наличия в Set требует <tex>O(|t|)</tex>. Проверка на совпадение нескольких символов подстрок требует константное время. Значит,на каждый шаг бинарного поиска требуется <tex>O(max(|s|, |t|))</tex> действий. Заметим, что всего для завершения бинарного поиска потребуется <tex>O(\log(\min(|s|, |t|)))</tex> шагов. Следовательно, суммарное время работы алгоритма будет <tex>O(\log(\min(|s|, |t|)) \cdot \max(|s|, |t|))</tex> действий.

== Литература ==
* Кормен Т., Лейзерсон Ч., Ривест Р. Алгоритмы: построение и анализ. — 2-е изд. — М.: Издательский дом «Вильямс», 2007. — С. 1296.

[[Категория:Алгоритмы и структуры данных]]
[[Категория:Поиск подстроки в строке]]

Поиск наибольшей общей подстроки двух строк с использованием хеширования

2012-09-12T13:39:25Z

194.85.160.130: /* Псевдокод */

==Постановка задачи==
Имеются строки <tex>s</tex> и <tex>t</tex> такие, что элементы этих строк <tex>-</tex> символы из конечного алфавита <tex> \Sigma </tex>. Говорят, что строка <tex>z[1 .. m]</tex> является подстрокой строки <tex>s[1 .. n]</tex>, если существует такой индекс <tex>k \in [0 .. n - m]</tex>, что для любого <tex>i \in [1 .. m]</tex> справедливо <tex>s[k + i] = z[i]</tex>. Требуется найти такую строку <tex>z</tex> максимальной длины, что <tex>z</tex> является и подстрокой <tex>s</tex>, и подстрокой <tex>t</tex>.

==Алгоритм==
Пусть длина наибольшей общей подстроки будет <tex>x</tex>. Заметим, что у строк <tex>s</tex> и <tex>t</tex> обязательно найдется общая подстрока длины <tex>y \in [0 .. x]</tex>, так как в качестве такой строки можно взять префикс наибольшей общей подстроки. Рассмотрим функцию <tex>f : [0 .. \min(|s|, |t|)] \rightarrow \{0, 1\}</tex>, которая для <tex>i</tex> из области определения равна 1, если у строк <tex>s</tex> и <tex>t</tex> есть общая подстрока длины <tex>i</tex>, иначе она равна 0. Согласно замечанию, функция <tex>f</tex> должна по мере возрастания <tex>i</tex> быть равной 1 до некоторого момента, а затем обращаться в 0. Собственно, максимальное значение, при котором функция принимает значение 1, является длиной наибольшей общей подстроки. Таким образом, требуется с помощью [[Целочисленный двоичный поиск|двоичного поиска]] найти это значение. В ходе работы придется проверять наличие общей подстроки заданной длины. Для этого будем использовать хеширование, чтобы улучшить асимптотику алгоритма. Алгоритм является эвристическим и может выдавать неверный ответ, так как совпадение хешей строк не гарантирует равенство строк. Поэтому нужно выполнить проверку нескольких случайных символов подстрок на совпадение, проиграв при этом по времени работы. Алгоритм работает следующим образом:

1) У строки <tex>s</tex> хешируем подстроки заданной длины и полученные хеши записываем в Set.

2) У строки <tex>t</tex> хешируем подстроки заданной длины и в случае совпадения хеша с элементом Set проверяем несколько случайных символов подстрок на совпадение.

Хеширование будем производить так же, как и в [[Поиск подстроки в строке с использованием хеширования. Алгоритм Рабина-Карпа|алгоритме Рабина-Карпа]].

== Псевдокод ==

<tex>f</tex> — функция, описанная в алгоритме.
<tex>i</tex> - длина подстроки, найденная с помощью [[Целочисленный двоичный поиск|двоичного поиска]].

<tex>f(i)</tex>
Записываем в <tex>S</tex> хэши подстрок строки <tex>s</tex> длины <tex>i</tex>;
'''for''' <tex>j = 1...|t| - i</tex>
Считаем хэш от подстоки <tex>t[j .. j + i]</tex>;
'''if''' хэш содержится в <tex>S</tex>
'''if''' совпали несколько случайных символов подсток
return 1;
'''else'''
continue;
return 0;

==Время работы==
Проведем оценку асимптотики времени работы предложенного алгоритма. Посмотрим сколько нам потребуется действий на каждом шаге бинарного поиска. Во-первых, хеширование подстрок строки <tex>s</tex> и запись их в Set требует <tex>O(|s|)</tex> шагов. Во-вторых, хеширование подстрок строки <tex>t</tex> и проверка их наличия в Set требует <tex>O(|t|)</tex>. Проверка на совпадение нескольких символов подстрок требует константное время. Значит,на каждый шаг бинарного поиска требуется <tex>O(max(|s|, |t|))</tex> действий. Заметим, что всего для завершения бинарного поиска потребуется <tex>O(\log(\min(|s|, |t|)))</tex> шагов. Следовательно, суммарное время работы алгоритма будет <tex>O(\log(\min(|s|, |t|)) \cdot \max(|s|, |t|))</tex> действий.

== Литература ==
* Кормен Т., Лейзерсон Ч., Ривест Р. Алгоритмы: построение и анализ. — 2-е изд. — М.: Издательский дом «Вильямс», 2007. — С. 1296.

[[Категория:Алгоритмы и структуры данных]]
[[Категория:Поиск подстроки в строке]]

Поиск наибольшей общей подстроки двух строк с использованием хеширования

2012-09-12T13:38:50Z

194.85.160.130: /* Псевдокод */

==Постановка задачи==
Имеются строки <tex>s</tex> и <tex>t</tex> такие, что элементы этих строк <tex>-</tex> символы из конечного алфавита <tex> \Sigma </tex>. Говорят, что строка <tex>z[1 .. m]</tex> является подстрокой строки <tex>s[1 .. n]</tex>, если существует такой индекс <tex>k \in [0 .. n - m]</tex>, что для любого <tex>i \in [1 .. m]</tex> справедливо <tex>s[k + i] = z[i]</tex>. Требуется найти такую строку <tex>z</tex> максимальной длины, что <tex>z</tex> является и подстрокой <tex>s</tex>, и подстрокой <tex>t</tex>.

==Алгоритм==
Пусть длина наибольшей общей подстроки будет <tex>x</tex>. Заметим, что у строк <tex>s</tex> и <tex>t</tex> обязательно найдется общая подстрока длины <tex>y \in [0 .. x]</tex>, так как в качестве такой строки можно взять префикс наибольшей общей подстроки. Рассмотрим функцию <tex>f : [0 .. \min(|s|, |t|)] \rightarrow \{0, 1\}</tex>, которая для <tex>i</tex> из области определения равна 1, если у строк <tex>s</tex> и <tex>t</tex> есть общая подстрока длины <tex>i</tex>, иначе она равна 0. Согласно замечанию, функция <tex>f</tex> должна по мере возрастания <tex>i</tex> быть равной 1 до некоторого момента, а затем обращаться в 0. Собственно, максимальное значение, при котором функция принимает значение 1, является длиной наибольшей общей подстроки. Таким образом, требуется с помощью [[Целочисленный двоичный поиск|двоичного поиска]] найти это значение. В ходе работы придется проверять наличие общей подстроки заданной длины. Для этого будем использовать хеширование, чтобы улучшить асимптотику алгоритма. Алгоритм является эвристическим и может выдавать неверный ответ, так как совпадение хешей строк не гарантирует равенство строк. Поэтому нужно выполнить проверку нескольких случайных символов подстрок на совпадение, проиграв при этом по времени работы. Алгоритм работает следующим образом:

1) У строки <tex>s</tex> хешируем подстроки заданной длины и полученные хеши записываем в Set.

2) У строки <tex>t</tex> хешируем подстроки заданной длины и в случае совпадения хеша с элементом Set проверяем несколько случайных символов подстрок на совпадение.

Хеширование будем производить так же, как и в [[Поиск подстроки в строке с использованием хеширования. Алгоритм Рабина-Карпа|алгоритме Рабина-Карпа]].

== Псевдокод ==

<tex>f</tex> — функция, описанная в алгоритме.
<tex>i</tex> - длина подстроки, найденная с помощью [[Целочисленный двоичный поиск|двоичного поиска]].
<tex>f(i)</tex>
Записываем в <tex>S</tex> хэши подстрок строки <tex>s</tex> длины <tex>i</tex>;
'''for''' <tex>j = 1...|t| - i</tex>
Считаем хэш от подстоки <tex>t[j .. j + i]</tex>;
'''if''' хэш содержится в <tex>S</tex>
'''if''' совпали несколько случайных символов подсток
return 1;
'''else'''
continue;
return 0;

==Время работы==
Проведем оценку асимптотики времени работы предложенного алгоритма. Посмотрим сколько нам потребуется действий на каждом шаге бинарного поиска. Во-первых, хеширование подстрок строки <tex>s</tex> и запись их в Set требует <tex>O(|s|)</tex> шагов. Во-вторых, хеширование подстрок строки <tex>t</tex> и проверка их наличия в Set требует <tex>O(|t|)</tex>. Проверка на совпадение нескольких символов подстрок требует константное время. Значит,на каждый шаг бинарного поиска требуется <tex>O(max(|s|, |t|))</tex> действий. Заметим, что всего для завершения бинарного поиска потребуется <tex>O(\log(\min(|s|, |t|)))</tex> шагов. Следовательно, суммарное время работы алгоритма будет <tex>O(\log(\min(|s|, |t|)) \cdot \max(|s|, |t|))</tex> действий.

== Литература ==
* Кормен Т., Лейзерсон Ч., Ривест Р. Алгоритмы: построение и анализ. — 2-е изд. — М.: Издательский дом «Вильямс», 2007. — С. 1296.

[[Категория:Алгоритмы и структуры данных]]
[[Категория:Поиск подстроки в строке]]

Поиск наибольшей общей подстроки двух строк с использованием хеширования

2012-09-12T13:34:00Z

194.85.160.130: /* Псевдокод */

==Постановка задачи==
Имеются строки <tex>s</tex> и <tex>t</tex> такие, что элементы этих строк <tex>-</tex> символы из конечного алфавита <tex> \Sigma </tex>. Говорят, что строка <tex>z[1 .. m]</tex> является подстрокой строки <tex>s[1 .. n]</tex>, если существует такой индекс <tex>k \in [0 .. n - m]</tex>, что для любого <tex>i \in [1 .. m]</tex> справедливо <tex>s[k + i] = z[i]</tex>. Требуется найти такую строку <tex>z</tex> максимальной длины, что <tex>z</tex> является и подстрокой <tex>s</tex>, и подстрокой <tex>t</tex>.

==Алгоритм==
Пусть длина наибольшей общей подстроки будет <tex>x</tex>. Заметим, что у строк <tex>s</tex> и <tex>t</tex> обязательно найдется общая подстрока длины <tex>y \in [0 .. x]</tex>, так как в качестве такой строки можно взять префикс наибольшей общей подстроки. Рассмотрим функцию <tex>f : [0 .. \min(|s|, |t|)] \rightarrow \{0, 1\}</tex>, которая для <tex>i</tex> из области определения равна 1, если у строк <tex>s</tex> и <tex>t</tex> есть общая подстрока длины <tex>i</tex>, иначе она равна 0. Согласно замечанию, функция <tex>f</tex> должна по мере возрастания <tex>i</tex> быть равной 1 до некоторого момента, а затем обращаться в 0. Собственно, максимальное значение, при котором функция принимает значение 1, является длиной наибольшей общей подстроки. Таким образом, требуется с помощью [[Целочисленный двоичный поиск|двоичного поиска]] найти это значение. В ходе работы придется проверять наличие общей подстроки заданной длины. Для этого будем использовать хеширование, чтобы улучшить асимптотику алгоритма. Алгоритм является эвристическим и может выдавать неверный ответ, так как совпадение хешей строк не гарантирует равенство строк. Поэтому нужно выполнить проверку нескольких случайных символов подстрок на совпадение, проиграв при этом по времени работы. Алгоритм работает следующим образом:

1) У строки <tex>s</tex> хешируем подстроки заданной длины и полученные хеши записываем в Set.

2) У строки <tex>t</tex> хешируем подстроки заданной длины и в случае совпадения хеша с элементом Set проверяем несколько случайных символов подстрок на совпадение.

Хеширование будем производить так же, как и в [[Поиск подстроки в строке с использованием хеширования. Алгоритм Рабина-Карпа|алгоритме Рабина-Карпа]].

== Псевдокод ==

<tex>f</tex> — функция, описанная в алгоритме.

<tex>f(i)</tex>
Записываем в <tex>S</tex> хэши подстрок строки <tex>s</tex> длины <tex>i</tex>;
'''for''' <tex>j = 1...|t| - i</tex>
Считаем хэш от подстоки <tex>t[j .. j + i]</tex>;
'''if''' хэш содержится в <tex>S</tex>
'''if''' совпали несколько случайных символов подсток
return 1;
'''else'''
continue;
return 0;

==Время работы==
Проведем оценку асимптотики времени работы предложенного алгоритма. Посмотрим сколько нам потребуется действий на каждом шаге бинарного поиска. Во-первых, хеширование подстрок строки <tex>s</tex> и запись их в Set требует <tex>O(|s|)</tex> шагов. Во-вторых, хеширование подстрок строки <tex>t</tex> и проверка их наличия в Set требует <tex>O(|t|)</tex>. Проверка на совпадение нескольких символов подстрок требует константное время. Значит,на каждый шаг бинарного поиска требуется <tex>O(max(|s|, |t|))</tex> действий. Заметим, что всего для завершения бинарного поиска потребуется <tex>O(\log(\min(|s|, |t|)))</tex> шагов. Следовательно, суммарное время работы алгоритма будет <tex>O(\log(\min(|s|, |t|)) \cdot \max(|s|, |t|))</tex> действий.

== Литература ==
* Кормен Т., Лейзерсон Ч., Ривест Р. Алгоритмы: построение и анализ. — 2-е изд. — М.: Издательский дом «Вильямс», 2007. — С. 1296.

[[Категория:Алгоритмы и структуры данных]]
[[Категория:Поиск подстроки в строке]]

Поиск наибольшей общей подстроки двух строк с использованием хеширования

2012-09-12T13:33:23Z

194.85.160.130: /* Псевдокод */

==Постановка задачи==
Имеются строки <tex>s</tex> и <tex>t</tex> такие, что элементы этих строк <tex>-</tex> символы из конечного алфавита <tex> \Sigma </tex>. Говорят, что строка <tex>z[1 .. m]</tex> является подстрокой строки <tex>s[1 .. n]</tex>, если существует такой индекс <tex>k \in [0 .. n - m]</tex>, что для любого <tex>i \in [1 .. m]</tex> справедливо <tex>s[k + i] = z[i]</tex>. Требуется найти такую строку <tex>z</tex> максимальной длины, что <tex>z</tex> является и подстрокой <tex>s</tex>, и подстрокой <tex>t</tex>.

==Алгоритм==
Пусть длина наибольшей общей подстроки будет <tex>x</tex>. Заметим, что у строк <tex>s</tex> и <tex>t</tex> обязательно найдется общая подстрока длины <tex>y \in [0 .. x]</tex>, так как в качестве такой строки можно взять префикс наибольшей общей подстроки. Рассмотрим функцию <tex>f : [0 .. \min(|s|, |t|)] \rightarrow \{0, 1\}</tex>, которая для <tex>i</tex> из области определения равна 1, если у строк <tex>s</tex> и <tex>t</tex> есть общая подстрока длины <tex>i</tex>, иначе она равна 0. Согласно замечанию, функция <tex>f</tex> должна по мере возрастания <tex>i</tex> быть равной 1 до некоторого момента, а затем обращаться в 0. Собственно, максимальное значение, при котором функция принимает значение 1, является длиной наибольшей общей подстроки. Таким образом, требуется с помощью [[Целочисленный двоичный поиск|двоичного поиска]] найти это значение. В ходе работы придется проверять наличие общей подстроки заданной длины. Для этого будем использовать хеширование, чтобы улучшить асимптотику алгоритма. Алгоритм является эвристическим и может выдавать неверный ответ, так как совпадение хешей строк не гарантирует равенство строк. Поэтому нужно выполнить проверку нескольких случайных символов подстрок на совпадение, проиграв при этом по времени работы. Алгоритм работает следующим образом:

1) У строки <tex>s</tex> хешируем подстроки заданной длины и полученные хеши записываем в Set.

2) У строки <tex>t</tex> хешируем подстроки заданной длины и в случае совпадения хеша с элементом Set проверяем несколько случайных символов подстрок на совпадение.

Хеширование будем производить так же, как и в [[Поиск подстроки в строке с использованием хеширования. Алгоритм Рабина-Карпа|алгоритме Рабина-Карпа]].

== Псевдокод ==

<tex>f</tex> — функция, описанная в алгоритме.

f(i)
Записываем в <tex>S</tex> хэши подстрок строки <tex>s</tex> длины <tex>i</tex>;
'''for''' <tex>j = 1...|t| - i</tex>
Считаем хэш от подстоки <tex>t[j .. j + i]</tex>;
'''if''' хэш содержится в <tex>S</tex>
'''if''' совпали несколько случайных символов подсток
return 1;
'''else'''
continue;
return 0;

==Время работы==
Проведем оценку асимптотики времени работы предложенного алгоритма. Посмотрим сколько нам потребуется действий на каждом шаге бинарного поиска. Во-первых, хеширование подстрок строки <tex>s</tex> и запись их в Set требует <tex>O(|s|)</tex> шагов. Во-вторых, хеширование подстрок строки <tex>t</tex> и проверка их наличия в Set требует <tex>O(|t|)</tex>. Проверка на совпадение нескольких символов подстрок требует константное время. Значит,на каждый шаг бинарного поиска требуется <tex>O(max(|s|, |t|))</tex> действий. Заметим, что всего для завершения бинарного поиска потребуется <tex>O(\log(\min(|s|, |t|)))</tex> шагов. Следовательно, суммарное время работы алгоритма будет <tex>O(\log(\min(|s|, |t|)) \cdot \max(|s|, |t|))</tex> действий.

== Литература ==
* Кормен Т., Лейзерсон Ч., Ривест Р. Алгоритмы: построение и анализ. — 2-е изд. — М.: Издательский дом «Вильямс», 2007. — С. 1296.

[[Категория:Алгоритмы и структуры данных]]
[[Категория:Поиск подстроки в строке]]

Поиск наибольшей общей подстроки двух строк с использованием хеширования

2012-09-12T13:32:14Z

194.85.160.130: /* Псевдокод */

==Постановка задачи==
Имеются строки <tex>s</tex> и <tex>t</tex> такие, что элементы этих строк <tex>-</tex> символы из конечного алфавита <tex> \Sigma </tex>. Говорят, что строка <tex>z[1 .. m]</tex> является подстрокой строки <tex>s[1 .. n]</tex>, если существует такой индекс <tex>k \in [0 .. n - m]</tex>, что для любого <tex>i \in [1 .. m]</tex> справедливо <tex>s[k + i] = z[i]</tex>. Требуется найти такую строку <tex>z</tex> максимальной длины, что <tex>z</tex> является и подстрокой <tex>s</tex>, и подстрокой <tex>t</tex>.

==Алгоритм==
Пусть длина наибольшей общей подстроки будет <tex>x</tex>. Заметим, что у строк <tex>s</tex> и <tex>t</tex> обязательно найдется общая подстрока длины <tex>y \in [0 .. x]</tex>, так как в качестве такой строки можно взять префикс наибольшей общей подстроки. Рассмотрим функцию <tex>f : [0 .. \min(|s|, |t|)] \rightarrow \{0, 1\}</tex>, которая для <tex>i</tex> из области определения равна 1, если у строк <tex>s</tex> и <tex>t</tex> есть общая подстрока длины <tex>i</tex>, иначе она равна 0. Согласно замечанию, функция <tex>f</tex> должна по мере возрастания <tex>i</tex> быть равной 1 до некоторого момента, а затем обращаться в 0. Собственно, максимальное значение, при котором функция принимает значение 1, является длиной наибольшей общей подстроки. Таким образом, требуется с помощью [[Целочисленный двоичный поиск|двоичного поиска]] найти это значение. В ходе работы придется проверять наличие общей подстроки заданной длины. Для этого будем использовать хеширование, чтобы улучшить асимптотику алгоритма. Алгоритм является эвристическим и может выдавать неверный ответ, так как совпадение хешей строк не гарантирует равенство строк. Поэтому нужно выполнить проверку нескольких случайных символов подстрок на совпадение, проиграв при этом по времени работы. Алгоритм работает следующим образом:

1) У строки <tex>s</tex> хешируем подстроки заданной длины и полученные хеши записываем в Set.

2) У строки <tex>t</tex> хешируем подстроки заданной длины и в случае совпадения хеша с элементом Set проверяем несколько случайных символов подстрок на совпадение.

Хеширование будем производить так же, как и в [[Поиск подстроки в строке с использованием хеширования. Алгоритм Рабина-Карпа|алгоритме Рабина-Карпа]].

== Псевдокод ==

<tex>f</tex> — функция, описанная в алгоритме.

f(i)
Записываем в <tex>S</tex> хэши подстрок строки <tex>s</tex> длины <tex>i</tex>
'''for''' <tex>j = 1...|t| - i</tex>
Считаем хэш от подстоки <tex>t[j .. j + i]</tex>
'''if''' хэш содержится в <tex>S</tex>
'''if''' совпали несколько случайных символов подсток
return 1;
'''else'''
continue;
return 0;

==Время работы==
Проведем оценку асимптотики времени работы предложенного алгоритма. Посмотрим сколько нам потребуется действий на каждом шаге бинарного поиска. Во-первых, хеширование подстрок строки <tex>s</tex> и запись их в Set требует <tex>O(|s|)</tex> шагов. Во-вторых, хеширование подстрок строки <tex>t</tex> и проверка их наличия в Set требует <tex>O(|t|)</tex>. Проверка на совпадение нескольких символов подстрок требует константное время. Значит,на каждый шаг бинарного поиска требуется <tex>O(max(|s|, |t|))</tex> действий. Заметим, что всего для завершения бинарного поиска потребуется <tex>O(\log(\min(|s|, |t|)))</tex> шагов. Следовательно, суммарное время работы алгоритма будет <tex>O(\log(\min(|s|, |t|)) \cdot \max(|s|, |t|))</tex> действий.

== Литература ==
* Кормен Т., Лейзерсон Ч., Ривест Р. Алгоритмы: построение и анализ. — 2-е изд. — М.: Издательский дом «Вильямс», 2007. — С. 1296.

[[Категория:Алгоритмы и структуры данных]]
[[Категория:Поиск подстроки в строке]]

Поиск наибольшей общей подстроки двух строк с использованием хеширования

2012-09-12T13:29:35Z

194.85.160.130: /* Псевдокод */

==Постановка задачи==
Имеются строки <tex>s</tex> и <tex>t</tex> такие, что элементы этих строк <tex>-</tex> символы из конечного алфавита <tex> \Sigma </tex>. Говорят, что строка <tex>z[1 .. m]</tex> является подстрокой строки <tex>s[1 .. n]</tex>, если существует такой индекс <tex>k \in [0 .. n - m]</tex>, что для любого <tex>i \in [1 .. m]</tex> справедливо <tex>s[k + i] = z[i]</tex>. Требуется найти такую строку <tex>z</tex> максимальной длины, что <tex>z</tex> является и подстрокой <tex>s</tex>, и подстрокой <tex>t</tex>.

==Алгоритм==
Пусть длина наибольшей общей подстроки будет <tex>x</tex>. Заметим, что у строк <tex>s</tex> и <tex>t</tex> обязательно найдется общая подстрока длины <tex>y \in [0 .. x]</tex>, так как в качестве такой строки можно взять префикс наибольшей общей подстроки. Рассмотрим функцию <tex>f : [0 .. \min(|s|, |t|)] \rightarrow \{0, 1\}</tex>, которая для <tex>i</tex> из области определения равна 1, если у строк <tex>s</tex> и <tex>t</tex> есть общая подстрока длины <tex>i</tex>, иначе она равна 0. Согласно замечанию, функция <tex>f</tex> должна по мере возрастания <tex>i</tex> быть равной 1 до некоторого момента, а затем обращаться в 0. Собственно, максимальное значение, при котором функция принимает значение 1, является длиной наибольшей общей подстроки. Таким образом, требуется с помощью [[Целочисленный двоичный поиск|двоичного поиска]] найти это значение. В ходе работы придется проверять наличие общей подстроки заданной длины. Для этого будем использовать хеширование, чтобы улучшить асимптотику алгоритма. Алгоритм является эвристическим и может выдавать неверный ответ, так как совпадение хешей строк не гарантирует равенство строк. Поэтому нужно выполнить проверку нескольких случайных символов подстрок на совпадение, проиграв при этом по времени работы. Алгоритм работает следующим образом:

1) У строки <tex>s</tex> хешируем подстроки заданной длины и полученные хеши записываем в Set.

2) У строки <tex>t</tex> хешируем подстроки заданной длины и в случае совпадения хеша с элементом Set проверяем несколько случайных символов подстрок на совпадение.

Хеширование будем производить так же, как и в [[Поиск подстроки в строке с использованием хеширования. Алгоритм Рабина-Карпа|алгоритме Рабина-Карпа]].

== Псевдокод ==

<tex>f</tex> — функция, описанная в алгоритме.

f(i)
Записываем в <tex>S</tex> хэши подстрок строки <tex>s</tex> длины <tex>i</tex>
'''for''' <tex>j = 1...|t| - i</tex>
Считаем хэш от подстоки <tex>t[j .. j + i]</tex>
'''if''' хэш содержится в <tex>S</tex>
'''if''' совпали несколько случайных символов подсток
'''return''' 1
'''else'''
'''return''' 0
'''return''' 0

==Время работы==
Проведем оценку асимптотики времени работы предложенного алгоритма. Посмотрим сколько нам потребуется действий на каждом шаге бинарного поиска. Во-первых, хеширование подстрок строки <tex>s</tex> и запись их в Set требует <tex>O(|s|)</tex> шагов. Во-вторых, хеширование подстрок строки <tex>t</tex> и проверка их наличия в Set требует <tex>O(|t|)</tex>. Проверка на совпадение нескольких символов подстрок требует константное время. Значит,на каждый шаг бинарного поиска требуется <tex>O(max(|s|, |t|))</tex> действий. Заметим, что всего для завершения бинарного поиска потребуется <tex>O(\log(\min(|s|, |t|)))</tex> шагов. Следовательно, суммарное время работы алгоритма будет <tex>O(\log(\min(|s|, |t|)) \cdot \max(|s|, |t|))</tex> действий.

== Литература ==
* Кормен Т., Лейзерсон Ч., Ривест Р. Алгоритмы: построение и анализ. — 2-е изд. — М.: Издательский дом «Вильямс», 2007. — С. 1296.

[[Категория:Алгоритмы и структуры данных]]
[[Категория:Поиск подстроки в строке]]

Поиск наибольшей общей подстроки двух строк с использованием хеширования

2012-09-12T13:28:47Z

194.85.160.130: /* Псевдокод */

==Постановка задачи==
Имеются строки <tex>s</tex> и <tex>t</tex> такие, что элементы этих строк <tex>-</tex> символы из конечного алфавита <tex> \Sigma </tex>. Говорят, что строка <tex>z[1 .. m]</tex> является подстрокой строки <tex>s[1 .. n]</tex>, если существует такой индекс <tex>k \in [0 .. n - m]</tex>, что для любого <tex>i \in [1 .. m]</tex> справедливо <tex>s[k + i] = z[i]</tex>. Требуется найти такую строку <tex>z</tex> максимальной длины, что <tex>z</tex> является и подстрокой <tex>s</tex>, и подстрокой <tex>t</tex>.

==Алгоритм==
Пусть длина наибольшей общей подстроки будет <tex>x</tex>. Заметим, что у строк <tex>s</tex> и <tex>t</tex> обязательно найдется общая подстрока длины <tex>y \in [0 .. x]</tex>, так как в качестве такой строки можно взять префикс наибольшей общей подстроки. Рассмотрим функцию <tex>f : [0 .. \min(|s|, |t|)] \rightarrow \{0, 1\}</tex>, которая для <tex>i</tex> из области определения равна 1, если у строк <tex>s</tex> и <tex>t</tex> есть общая подстрока длины <tex>i</tex>, иначе она равна 0. Согласно замечанию, функция <tex>f</tex> должна по мере возрастания <tex>i</tex> быть равной 1 до некоторого момента, а затем обращаться в 0. Собственно, максимальное значение, при котором функция принимает значение 1, является длиной наибольшей общей подстроки. Таким образом, требуется с помощью [[Целочисленный двоичный поиск|двоичного поиска]] найти это значение. В ходе работы придется проверять наличие общей подстроки заданной длины. Для этого будем использовать хеширование, чтобы улучшить асимптотику алгоритма. Алгоритм является эвристическим и может выдавать неверный ответ, так как совпадение хешей строк не гарантирует равенство строк. Поэтому нужно выполнить проверку нескольких случайных символов подстрок на совпадение, проиграв при этом по времени работы. Алгоритм работает следующим образом:

1) У строки <tex>s</tex> хешируем подстроки заданной длины и полученные хеши записываем в Set.

2) У строки <tex>t</tex> хешируем подстроки заданной длины и в случае совпадения хеша с элементом Set проверяем несколько случайных символов подстрок на совпадение.

Хеширование будем производить так же, как и в [[Поиск подстроки в строке с использованием хеширования. Алгоритм Рабина-Карпа|алгоритме Рабина-Карпа]].

== Псевдокод ==

<tex>f</tex> — функция, описанная в алгоритме.

f(i)
Записываем в <tex>S</tex> хэши подстрок строки <tex>s</tex> длины <tex>i</tex>
'''for''' <tex>j = 1...|t| - i</tex>
Считаем хэш от подстоки <tex>t[j .. j + i]</tex>
'''if''' хэш содержится в <tex>S</tex>
'''if''' совпали несколько случайных символов подсток
'''return''' 1
'''else'''
'''return''' 0
'''return''' 0

==Время работы==
Проведем оценку асимптотики времени работы предложенного алгоритма. Посмотрим сколько нам потребуется действий на каждом шаге бинарного поиска. Во-первых, хеширование подстрок строки <tex>s</tex> и запись их в Set требует <tex>O(|s|)</tex> шагов. Во-вторых, хеширование подстрок строки <tex>t</tex> и проверка их наличия в Set требует <tex>O(|t|)</tex>. Проверка на совпадение нескольких символов подстрок требует константное время. Значит,на каждый шаг бинарного поиска требуется <tex>O(max(|s|, |t|))</tex> действий. Заметим, что всего для завершения бинарного поиска потребуется <tex>O(\log(\min(|s|, |t|)))</tex> шагов. Следовательно, суммарное время работы алгоритма будет <tex>O(\log(\min(|s|, |t|)) \cdot \max(|s|, |t|))</tex> действий.

== Литература ==
* Кормен Т., Лейзерсон Ч., Ривест Р. Алгоритмы: построение и анализ. — 2-е изд. — М.: Издательский дом «Вильямс», 2007. — С. 1296.

[[Категория:Алгоритмы и структуры данных]]
[[Категория:Поиск подстроки в строке]]

Поиск наибольшей общей подстроки двух строк с использованием хеширования

2012-09-12T13:28:01Z

194.85.160.130: /* Псевдокод */

==Постановка задачи==
Имеются строки <tex>s</tex> и <tex>t</tex> такие, что элементы этих строк <tex>-</tex> символы из конечного алфавита <tex> \Sigma </tex>. Говорят, что строка <tex>z[1 .. m]</tex> является подстрокой строки <tex>s[1 .. n]</tex>, если существует такой индекс <tex>k \in [0 .. n - m]</tex>, что для любого <tex>i \in [1 .. m]</tex> справедливо <tex>s[k + i] = z[i]</tex>. Требуется найти такую строку <tex>z</tex> максимальной длины, что <tex>z</tex> является и подстрокой <tex>s</tex>, и подстрокой <tex>t</tex>.

==Алгоритм==
Пусть длина наибольшей общей подстроки будет <tex>x</tex>. Заметим, что у строк <tex>s</tex> и <tex>t</tex> обязательно найдется общая подстрока длины <tex>y \in [0 .. x]</tex>, так как в качестве такой строки можно взять префикс наибольшей общей подстроки. Рассмотрим функцию <tex>f : [0 .. \min(|s|, |t|)] \rightarrow \{0, 1\}</tex>, которая для <tex>i</tex> из области определения равна 1, если у строк <tex>s</tex> и <tex>t</tex> есть общая подстрока длины <tex>i</tex>, иначе она равна 0. Согласно замечанию, функция <tex>f</tex> должна по мере возрастания <tex>i</tex> быть равной 1 до некоторого момента, а затем обращаться в 0. Собственно, максимальное значение, при котором функция принимает значение 1, является длиной наибольшей общей подстроки. Таким образом, требуется с помощью [[Целочисленный двоичный поиск|двоичного поиска]] найти это значение. В ходе работы придется проверять наличие общей подстроки заданной длины. Для этого будем использовать хеширование, чтобы улучшить асимптотику алгоритма. Алгоритм является эвристическим и может выдавать неверный ответ, так как совпадение хешей строк не гарантирует равенство строк. Поэтому нужно выполнить проверку нескольких случайных символов подстрок на совпадение, проиграв при этом по времени работы. Алгоритм работает следующим образом:

1) У строки <tex>s</tex> хешируем подстроки заданной длины и полученные хеши записываем в Set.

2) У строки <tex>t</tex> хешируем подстроки заданной длины и в случае совпадения хеша с элементом Set проверяем несколько случайных символов подстрок на совпадение.

Хеширование будем производить так же, как и в [[Поиск подстроки в строке с использованием хеширования. Алгоритм Рабина-Карпа|алгоритме Рабина-Карпа]].

== Псевдокод ==

<tex>f</tex> — функция, описанная в алгоритме.

f(i)
Записываем в <tex>S</tex> хэши подстрок строки <tex>s</tex> длины <tex>i</tex>
'''for''' <tex>j = 1...|t| - i</tex>
Считаем хэш от подстоки <tex>t[j .. j + i]</tex>
'''if''' хэш содержится в <tex>S</tex>
'''if''' совпали несколько случайных символов подсток
'''return''' <tex>1</tex>
'''else'''
'''return''' <tex>0</tex>
'''return''' <tex>0</tex>

==Время работы==
Проведем оценку асимптотики времени работы предложенного алгоритма. Посмотрим сколько нам потребуется действий на каждом шаге бинарного поиска. Во-первых, хеширование подстрок строки <tex>s</tex> и запись их в Set требует <tex>O(|s|)</tex> шагов. Во-вторых, хеширование подстрок строки <tex>t</tex> и проверка их наличия в Set требует <tex>O(|t|)</tex>. Проверка на совпадение нескольких символов подстрок требует константное время. Значит,на каждый шаг бинарного поиска требуется <tex>O(max(|s|, |t|))</tex> действий. Заметим, что всего для завершения бинарного поиска потребуется <tex>O(\log(\min(|s|, |t|)))</tex> шагов. Следовательно, суммарное время работы алгоритма будет <tex>O(\log(\min(|s|, |t|)) \cdot \max(|s|, |t|))</tex> действий.

== Литература ==
* Кормен Т., Лейзерсон Ч., Ривест Р. Алгоритмы: построение и анализ. — 2-е изд. — М.: Издательский дом «Вильямс», 2007. — С. 1296.

[[Категория:Алгоритмы и структуры данных]]
[[Категория:Поиск подстроки в строке]]

Поиск наибольшей общей подстроки двух строк с использованием хеширования

2012-09-12T13:00:00Z

194.85.160.130: /* Алгоритм */

==Постановка задачи==
Имеются строки <tex>s</tex> и <tex>t</tex> такие, что элементы этих строк <tex>-</tex> символы из конечного алфавита <tex> \Sigma </tex>. Говорят, что строка <tex>z[1 .. m]</tex> является подстрокой строки <tex>s[1 .. n]</tex>, если существует такой индекс <tex>k \in [0 .. n - m]</tex>, что для любого <tex>i \in [1 .. m]</tex> справедливо <tex>s[k + i] = z[i]</tex>. Требуется найти такую строку <tex>z</tex> максимальной длины, что <tex>z</tex> является и подстрокой <tex>s</tex>, и подстрокой <tex>t</tex>.

==Алгоритм==
Пусть длина наибольшей общей подстроки будет <tex>x</tex>. Заметим, что у строк <tex>s</tex> и <tex>t</tex> обязательно найдется общая подстрока длины <tex>y \in [0 .. x]</tex>, так как в качестве такой строки можно взять префикс наибольшей общей подстроки. Рассмотрим функцию <tex>f : [0 .. \min(|s|, |t|)] \rightarrow \{0, 1\}</tex>, которая для <tex>i</tex> из области определения равна 1, если у строк <tex>s</tex> и <tex>t</tex> есть общая подстрока длины <tex>i</tex>, иначе она равна 0. Согласно замечанию, функция <tex>f</tex> должна по мере возрастания <tex>i</tex> быть равной 1 до некоторого момента, а затем обращаться в 0. Собственно, максимальное значение, при котором функция принимает значение 1, является длиной наибольшей общей подстроки. Таким образом, требуется с помощью [[Целочисленный двоичный поиск|двоичного поиска]] найти это значение. В ходе работы придется проверять наличие общей подстроки заданной длины. Для этого будем использовать хеширование, чтобы улучшить асимптотику алгоритма. Алгоритм является эвристическим и может выдавать неверный ответ, так как совпадение хешей строк не гарантирует равенство строк. Поэтому нужно выполнить проверку нескольких случайных символов подстрок на совпадение, проиграв при этом по времени работы. Алгоритм работает следующим образом:

1) У строки <tex>s</tex> хешируем подстроки заданной длины и полученные хеши записываем в Set.

2) У строки <tex>t</tex> хешируем подстроки заданной длины и в случае совпадения хеша с элементом Set проверяем несколько случайных символов подстрок на совпадение.

Хеширование будем производить так же, как и в [[Поиск подстроки в строке с использованием хеширования. Алгоритм Рабина-Карпа|алгоритме Рабина-Карпа]].

== Псевдокод ==

<tex>f</tex> — функция, описанная в алгоритме.

'''findGCS'''(s, t)
n = min(|s|, |t|)
left = 0
right = n + 1
'''while''' (right - left > 1):
val = (left + right) / 2
'''if''' ('''f'''(val) == 1)
left = val
'''else'''
right = val
'''return''' left

==Время работы==
Проведем оценку асимптотики времени работы предложенного алгоритма. Посмотрим сколько нам потребуется действий на каждом шаге бинарного поиска. Во-первых, хеширование подстрок строки <tex>s</tex> и запись их в Set требует <tex>O(|s|)</tex> шагов. Во-вторых, хеширование подстрок строки <tex>t</tex> и проверка их наличия в Set требует <tex>O(|t|)</tex>. Проверка на совпадение нескольких символов подстрок требует константное время. Значит,на каждый шаг бинарного поиска требуется <tex>O(max(|s|, |t|))</tex> действий. Заметим, что всего для завершения бинарного поиска потребуется <tex>O(\log(\min(|s|, |t|)))</tex> шагов. Следовательно, суммарное время работы алгоритма будет <tex>O(\log(\min(|s|, |t|)) \cdot \max(|s|, |t|))</tex> действий.

== Литература ==
* Кормен Т., Лейзерсон Ч., Ривест Р. Алгоритмы: построение и анализ. — 2-е изд. — М.: Издательский дом «Вильямс», 2007. — С. 1296.

[[Категория:Алгоритмы и структуры данных]]
[[Категория:Поиск подстроки в строке]]

Задача многокритериальной оптимизации. Multiobjectivization

2012-06-20T12:58:15Z

194.85.160.130: /* Hierarchical-if-and-only-if function */

== Введение ==
В данной статье рассматривается многокритериальная оптимизация, её задача. Рассматривается понятие Парето-фронт - множество Парето оптимальных значений. Также рассматривается задача коммивояжера и предлагается алгоритм её мультиобъективизации

== Задача многокритериальной оптимизации ==
=== Постановка задачи ===
{{Определение
|definition=
'''Задача многокритериальной оптимизации:'''
:<math>maximize \{f(x) = (f_1(x),\dots,f_K(x))\}</math>
:<math> x \in X</math>
где <math> f(x) : X \rightarrow R^K</math> – целевая вектор-функция, где <math>K \ge 2</math>
}}
Так как не существует единого решение, которое было бы максимальным для всех целевых функций, вместо него можно искать множество <math>X^* \subseteq X </math> множество Парето оптимальных значений.
=== Множество Парето оптимальных значений ===
{{Определение
|definition=
''' Множество Парето оптимальных значений: '''
:<math>\forall x^* \in X^* \not\exists x \in X </math>:<math>x \succ x^*</math>, где <math>x \succ x^* \Leftrightarrow (\forall i \in 1..K, (f_i(x) \ge f_i(x^*))\land (\exists i \in 1..K, f_i(x) > f_i(x^*)))</math>
}}
Выражение <math>x \succ x^*</math> означает, что <math>x</math> ''доминирует над'' <math>x^*</math>.

Говорят, что <math>x</math> ''доминирует над'' <math>x^*</math>. по
Парето, если <math>x</math> не хуже <math>x^*</math> по всем критериям и хотя бы по одному критерию превосходит <math>x^*</math>.
В таком случае в выборе <math>x^*</math> нет смысла, т.к. <math>x</math> по всем параметрам не уступает, а по каким-то и превосхожит <math>x^*</math>. Если рассматривать всего
два критерия то на рис. 1 показана область
пространства, доминируемая данным решением А. Эта область «замкнута»:
элементы на ее границе также доминируемы А
[[Файл:Dogmin points.jpg|мини|200px|Рис.1 – Доминируемые решения ]]

{{Определение
|definition=
Для двух решений <math>x</math> и <math>x'</math> говорят <math>x \sim x'</math> тогда и только тогда, когда <math>\exists i \in 1..K \colon f_i(x) > f_i(x') \land \exists j \in 1..K, j \ne i \colon f_j(x') > f_j(x)</math> – такую пару решений называют '''недоминируемой'''
}}
На рис. 2 показана граница Парето для
возможных решений в двухкритериальном пространстве
[[Файл:Pareto_front.jpg|мини|200px|Рис.2 – Парето фронт]]
Множество Парето оптимальных недоминируемых решений называется '''Парето фронтом.'''

== Multi-objectivization ==
Суть метода мульти-объективизации заключается в разбитии сложной задачи с одной целевой функцией на несколько подзадач, найти для каждой подзадачи решение и выбрать оптимальное решение.

Для выполнения оптимизации многокритериальной задачи мы должны добавить в целевую функцию новые параметры, либо должны добавить новые целевые функции.

Сложность этой процедуры заключается в разложении проблемы на ряд мелких независимых между собой подпроблем.

== Алгоритмы ==

=== Hill-Climbers ===
{{Определение
|definition=
'''Hill-Climbers''' – Итеративный алгоритм, который начинается с произвольного решения проблемы, а затем пытается найти лучшее решение, постепенно изменяя его. Если изменения позволяют найти лучшее решение, алгоритм сохраняет его и повторяет и повторяет своё выполнение до тех пор, пока лучшие решения не могут быть найдены
}}

{|
|''Initialization:''||<math>P \leftarrow \emptyset </math> '''Init_pop'''<math>(P)</math>
|-
|''Main Loop:''||<math>x_1 \leftarrow </math>'''Rand_mem'''<math>(P)</math>,<math>x'_2 \leftarrow </math>'''Rand_mem'''<math>(P)</math> 
<math>x'_1 \leftarrow </math>'''Mutate'''<math>(P)</math>,<math>x_2 \leftarrow </math>'''Mutate'''<math>(P)</math> 
'''if'''<math>(H(x_1,x'_1)+H(x_2,x'_2) > H(x_1,x'_2)+H(x_2,x'_1))</math> 
:'''Swap'''<math>(x_1,x'_2)</math> 
'''if''' <math>f(x'_1) > f(x_1)</math> 
: <math>P \leftarrow P \cup x'_1 \setminus x_1</math> 
'''if''' <math>f(x'_2) > f(x_2)</math> 
: <math>P \leftarrow P \cup x'_2 \setminus x_2</math>
|-
|''Termination:''||'''return Best'''<math>(P)</math>
|}

== Задачи ==
====Hierarchical-if-and-only-if function====
'''H-IIF''' – предназначена для моделирования проблемы с блочной структурой, каждый блок которой строго связан с остальными блоками.

:<math>
f(B)= \begin{cases}1,& \mbox{if } |B| = 1, \mbox{ else}
\\|B|+f(B_L)+f(B_R),& \mbox{if }(\forall i \{b_i=0\} \mbox{ or } \forall i \{b_i = 1 \})
\\f(B_L) + f(B_R), & \mbox{otherwise}
\end{cases}
</math>,

где <math>B</math> – блок бит <math>\{b_1,b_2,\dots,b_n \}, |B|</math> – размер блока, а <math>B_L, B_R</math> – левая и правая часть блока соответственно.

Применяя к этой задаче мультиобъективизацию, разобьём задачу <math>f</math> на <math>k</math>-задач.

Представим, как будет выглядеть <math>f(B)</math>:

:<math>
f(B)= \begin{cases}
0, & \mbox{if } |B| = 1 \mbox{ and }b_1 \neq k, \mbox{ else}
\\1,& \mbox{if } |B| = 1 \mbox{ and }b_1 = k, \mbox{ else}
\\|B|+f_k(B_L)+f_k(B_R),& \mbox{if }(\forall i \{b_i=k\}),
\\f_k(B_L) + f_k(B_R), & \mbox{otherwise}
\end{cases}
</math>

где <math>f_0(x)</math> – первая цель; <math>f_0(x)</math> – вторая цель.

Данный подход помогает избежать проблему локальных максимумов (минимумов).

==== Задача коммивояжера ====
Задача коммивояжера (TSP)является наиболее известно из всего класса <math>NP</math>-сложных задач.
Формулируется задача следующим образом:

Задано <math>C=\{c_1,c_2,\dots,c_N\} </math> – множество городов и для каждой пары <math>\{c_i,c_j\}</math> задано расстояние. Наша цель – найти цепь из городов, минимизирующую величину:
:<math>\sum^{N-1}_{i=1} d(C_{\pi(i)},C_{\pi(i+1)})+d(C_{\pi(N)},C_{\pi(1)})</math>

Применяя к этой задаче мультиобъктивизацию, нужно разбить её на подзадачи. TSP – является <math>NP</math>-сложной именно потому, что нет хорошего разложения этой задачи.
Тем не менее задачу можно разбить на две или больше подтуров, каждый из которых мы можем минимизировать.

Представим подтуры в виде двух городов. Тогда наша задача примет вид:

:<math>minimize\{f(\pi,a,b) = (f_1(\pi,a,b),f_2(\pi,a,b))\}</math>
::'''where'''<math>f_1(\pi,a,b)=\sum^{\pi^{-1}(b)-1}_{i=\pi^{-1}(a)} d(C_{\pi(i)},C_{\pi(i+1)})</math>
::'''and''' <math>f_2(\pi,a,b)=\sum^{N-1}_{i=\pi^{-1}(b)} d(C_{\pi(i)},C_{\pi(i+1)}) + \sum^{\pi^{-1}(a)-1}_{i=1} d(C_{\pi(i)},C_{\pi(i+1)}) </math> <math>+ d(C_{\pi(N)},C_{\pi(1)})</math>,

где <math>a</math> и <math>b</math> – два города, указанных ''априори''. Если <math>\pi (a) < \pi (b)</math>, меняем их местами.

Предполагается, что <math>a</math> и <math>b</math> выбраны произвольно.

== Источники ==
* [http://ru.wikipedia.org/wiki/Многокритериальная_оптимизация Википедия: Многокритериальная оптимизация]
* [http://rain.ifmo.ru/~tsarev/teaching/ea-2012/lectures/3/multiobjectivization.pdf Knowles J., Watson R., Corne D. Reducing Local Optima in Single-Objective Problems by Multi-objectivization]
* [http://en.wikipedia.org/wiki/Multiobjective_optimization Wikipedia: Multiobjective optimization]
* [http://en.wikipedia.org/wiki/Hill_climbing Wikipedia: Hill climbing]

Задача многокритериальной оптимизации. Multiobjectivization

2012-06-20T12:55:36Z

194.85.160.130: /* Задачи */

== Введение ==
В данной статье рассматривается многокритериальная оптимизация, её задача. Рассматривается понятие Парето-фронт - множество Парето оптимальных значений. Также рассматривается задача коммивояжера и предлагается алгоритм её мультиобъективизации

== Задача многокритериальной оптимизации ==
=== Постановка задачи ===
{{Определение
|definition=
'''Задача многокритериальной оптимизации:'''
:<math>maximize \{f(x) = (f_1(x),\dots,f_K(x))\}</math>
:<math> x \in X</math>
где <math> f(x) : X \rightarrow R^K</math> – целевая вектор-функция, где <math>K \ge 2</math>
}}
Так как не существует единого решение, которое было бы максимальным для всех целевых функций, вместо него можно искать множество <math>X^* \subseteq X </math> множество Парето оптимальных значений.
=== Множество Парето оптимальных значений ===
{{Определение
|definition=
''' Множество Парето оптимальных значений: '''
:<math>\forall x^* \in X^* \not\exists x \in X </math>:<math>x \succ x^*</math>, где <math>x \succ x^* \Leftrightarrow (\forall i \in 1..K, (f_i(x) \ge f_i(x^*))\land (\exists i \in 1..K, f_i(x) > f_i(x^*)))</math>
}}
Выражение <math>x \succ x^*</math> означает, что <math>x</math> ''доминирует над'' <math>x^*</math>.

Говорят, что <math>x</math> ''доминирует над'' <math>x^*</math>. по
Парето, если <math>x</math> не хуже <math>x^*</math> по всем критериям и хотя бы по одному критерию превосходит <math>x^*</math>.
В таком случае в выборе <math>x^*</math> нет смысла, т.к. <math>x</math> по всем параметрам не уступает, а по каким-то и превосхожит <math>x^*</math>. Если рассматривать всего
два критерия то на рис. 1 показана область
пространства, доминируемая данным решением А. Эта область «замкнута»:
элементы на ее границе также доминируемы А
[[Файл:Dogmin points.jpg|мини|200px|Рис.1 – Доминируемые решения ]]

{{Определение
|definition=
Для двух решений <math>x</math> и <math>x'</math> говорят <math>x \sim x'</math> тогда и только тогда, когда <math>\exists i \in 1..K \colon f_i(x) > f_i(x') \land \exists j \in 1..K, j \ne i \colon f_j(x') > f_j(x)</math> – такую пару решений называют '''недоминируемой'''
}}
На рис. 2 показана граница Парето для
возможных решений в двухкритериальном пространстве
[[Файл:Pareto_front.jpg|мини|200px|Рис.2 – Парето фронт]]
Множество Парето оптимальных недоминируемых решений называется '''Парето фронтом.'''

== Multi-objectivization ==
Суть метода мульти-объективизации заключается в разбитии сложной задачи с одной целевой функцией на несколько подзадач, найти для каждой подзадачи решение и выбрать оптимальное решение.

Для выполнения оптимизации многокритериальной задачи мы должны добавить в целевую функцию новые параметры, либо должны добавить новые целевые функции.

Сложность этой процедуры заключается в разложении проблемы на ряд мелких независимых между собой подпроблем.

== Алгоритмы ==

=== Hill-Climbers ===
{{Определение
|definition=
'''Hill-Climbers''' – Итеративный алгоритм, который начинается с произвольного решения проблемы, а затем пытается найти лучшее решение, постепенно изменяя его. Если изменения позволяют найти лучшее решение, алгоритм сохраняет его и повторяет и повторяет своё выполнение до тех пор, пока лучшие решения не могут быть найдены
}}

{|
|''Initialization:''||<math>P \leftarrow \emptyset </math> '''Init_pop'''<math>(P)</math>
|-
|''Main Loop:''||<math>x_1 \leftarrow </math>'''Rand_mem'''<math>(P)</math>,<math>x'_2 \leftarrow </math>'''Rand_mem'''<math>(P)</math> 
<math>x'_1 \leftarrow </math>'''Mutate'''<math>(P)</math>,<math>x_2 \leftarrow </math>'''Mutate'''<math>(P)</math> 
'''if'''<math>(H(x_1,x'_1)+H(x_2,x'_2) > H(x_1,x'_2)+H(x_2,x'_1))</math> 
:'''Swap'''<math>(x_1,x'_2)</math> 
'''if''' <math>f(x'_1) > f(x_1)</math> 
: <math>P \leftarrow P \cup x'_1 \setminus x_1</math> 
'''if''' <math>f(x'_2) > f(x_2)</math> 
: <math>P \leftarrow P \cup x'_2 \setminus x_2</math>
|-
|''Termination:''||'''return Best'''<math>(P)</math>
|}

== Задачи ==
====Hierarchical-if-and-only-if function====
'''H-IIF''' – предназначена для моделирования проблемы с блочной структурой, каждый блок которой строго связан с остальными блоками.

:<math>
f(B)= \begin{cases}1,& \mbox{if } |B| = 1, \mbox{ else}
\\|B|+f(B_L)+f(B_R),& \mbox{if }(\forall i \{b_i=0\} \mbox{ or } \forall i \{b_i = 1 \})
\\f(B_L) + f(B_R), & \mbox{otherwise}
\end{cases}
</math>,

где <math>B</math> – блок бит <math>\{b_1,b_2,\dots,b_n \}, |B|</math> – размер блока, а <math>B_L, B_R</math> – левая и правая часть блока соответственно.

Применяя к этой задаче мультиобъективизацию, разобьём задачу <math>f</math> на <math>k</math>-задач.

Представим, как будет выглядеть <math>f(B)</math>:

:<math>
f(B)= \begin{cases}
0, & \mbox{if } |B| = 1 \mbox{ and }b_1 \neq k, \mbox{ else}
\\1,& \mbox{if } |B| = 1 \mbox{ and }b_1 = k, \mbox{ else}
\\|B|+f_k(B_L)+f_k(B_R),& \mbox{if }(\forall i \{b_i=k\}),
\\f_k(B_L) + f_k(B_R), & \mbox{otherwise}
\end{cases}
</math>

где <math>f_0(x)</math> – первая цель; <math>f_0(x)</math> – вторая цель.

==== Задача коммивояжера ====
Задача коммивояжера (TSP)является наиболее известно из всего класса <math>NP</math>-сложных задач.
Формулируется задача следующим образом:

Задано <math>C=\{c_1,c_2,\dots,c_N\} </math> – множество городов и для каждой пары <math>\{c_i,c_j\}</math> задано расстояние. Наша цель – найти цепь из городов, минимизирующую величину:
:<math>\sum^{N-1}_{i=1} d(C_{\pi(i)},C_{\pi(i+1)})+d(C_{\pi(N)},C_{\pi(1)})</math>

Применяя к этой задаче мультиобъктивизацию, нужно разбить её на подзадачи. TSP – является <math>NP</math>-сложной именно потому, что нет хорошего разложения этой задачи.
Тем не менее задачу можно разбить на две или больше подтуров, каждый из которых мы можем минимизировать.

Представим подтуры в виде двух городов. Тогда наша задача примет вид:

:<math>minimize\{f(\pi,a,b) = (f_1(\pi,a,b),f_2(\pi,a,b))\}</math>
::'''where'''<math>f_1(\pi,a,b)=\sum^{\pi^{-1}(b)-1}_{i=\pi^{-1}(a)} d(C_{\pi(i)},C_{\pi(i+1)})</math>
::'''and''' <math>f_2(\pi,a,b)=\sum^{N-1}_{i=\pi^{-1}(b)} d(C_{\pi(i)},C_{\pi(i+1)}) + \sum^{\pi^{-1}(a)-1}_{i=1} d(C_{\pi(i)},C_{\pi(i+1)}) </math> <math>+ d(C_{\pi(N)},C_{\pi(1)})</math>,

где <math>a</math> и <math>b</math> – два города, указанных ''априори''. Если <math>\pi (a) < \pi (b)</math>, меняем их местами.

Предполагается, что <math>a</math> и <math>b</math> выбраны произвольно.

== Источники ==
* [http://ru.wikipedia.org/wiki/Многокритериальная_оптимизация Википедия: Многокритериальная оптимизация]
* [http://rain.ifmo.ru/~tsarev/teaching/ea-2012/lectures/3/multiobjectivization.pdf Knowles J., Watson R., Corne D. Reducing Local Optima in Single-Objective Problems by Multi-objectivization]
* [http://en.wikipedia.org/wiki/Multiobjective_optimization Wikipedia: Multiobjective optimization]
* [http://en.wikipedia.org/wiki/Hill_climbing Wikipedia: Hill climbing]

Задача многокритериальной оптимизации. Multiobjectivization

2012-06-20T12:54:56Z

194.85.160.130: /* Задачи */

== Введение ==
В данной статье рассматривается многокритериальная оптимизация, её задача. Рассматривается понятие Парето-фронт - множество Парето оптимальных значений. Также рассматривается задача коммивояжера и предлагается алгоритм её мультиобъективизации

== Задача многокритериальной оптимизации ==
=== Постановка задачи ===
{{Определение
|definition=
'''Задача многокритериальной оптимизации:'''
:<math>maximize \{f(x) = (f_1(x),\dots,f_K(x))\}</math>
:<math> x \in X</math>
где <math> f(x) : X \rightarrow R^K</math> – целевая вектор-функция, где <math>K \ge 2</math>
}}
Так как не существует единого решение, которое было бы максимальным для всех целевых функций, вместо него можно искать множество <math>X^* \subseteq X </math> множество Парето оптимальных значений.
=== Множество Парето оптимальных значений ===
{{Определение
|definition=
''' Множество Парето оптимальных значений: '''
:<math>\forall x^* \in X^* \not\exists x \in X </math>:<math>x \succ x^*</math>, где <math>x \succ x^* \Leftrightarrow (\forall i \in 1..K, (f_i(x) \ge f_i(x^*))\land (\exists i \in 1..K, f_i(x) > f_i(x^*)))</math>
}}
Выражение <math>x \succ x^*</math> означает, что <math>x</math> ''доминирует над'' <math>x^*</math>.

Говорят, что <math>x</math> ''доминирует над'' <math>x^*</math>. по
Парето, если <math>x</math> не хуже <math>x^*</math> по всем критериям и хотя бы по одному критерию превосходит <math>x^*</math>.
В таком случае в выборе <math>x^*</math> нет смысла, т.к. <math>x</math> по всем параметрам не уступает, а по каким-то и превосхожит <math>x^*</math>. Если рассматривать всего
два критерия то на рис. 1 показана область
пространства, доминируемая данным решением А. Эта область «замкнута»:
элементы на ее границе также доминируемы А
[[Файл:Dogmin points.jpg|мини|200px|Рис.1 – Доминируемые решения ]]

{{Определение
|definition=
Для двух решений <math>x</math> и <math>x'</math> говорят <math>x \sim x'</math> тогда и только тогда, когда <math>\exists i \in 1..K \colon f_i(x) > f_i(x') \land \exists j \in 1..K, j \ne i \colon f_j(x') > f_j(x)</math> – такую пару решений называют '''недоминируемой'''
}}
На рис. 2 показана граница Парето для
возможных решений в двухкритериальном пространстве
[[Файл:Pareto_front.jpg|мини|200px|Рис.2 – Парето фронт]]
Множество Парето оптимальных недоминируемых решений называется '''Парето фронтом.'''

== Multi-objectivization ==
Суть метода мульти-объективизации заключается в разбитии сложной задачи с одной целевой функцией на несколько подзадач, найти для каждой подзадачи решение и выбрать оптимальное решение.

Для выполнения оптимизации многокритериальной задачи мы должны добавить в целевую функцию новые параметры, либо должны добавить новые целевые функции.

Сложность этой процедуры заключается в разложении проблемы на ряд мелких независимых между собой подпроблем.

== Алгоритмы ==

=== Hill-Climbers ===
{{Определение
|definition=
'''Hill-Climbers''' – Итеративный алгоритм, который начинается с произвольного решения проблемы, а затем пытается найти лучшее решение, постепенно изменяя его. Если изменения позволяют найти лучшее решение, алгоритм сохраняет его и повторяет и повторяет своё выполнение до тех пор, пока лучшие решения не могут быть найдены
}}

{|
|''Initialization:''||<math>P \leftarrow \emptyset </math> '''Init_pop'''<math>(P)</math>
|-
|''Main Loop:''||<math>x_1 \leftarrow </math>'''Rand_mem'''<math>(P)</math>,<math>x'_2 \leftarrow </math>'''Rand_mem'''<math>(P)</math> 
<math>x'_1 \leftarrow </math>'''Mutate'''<math>(P)</math>,<math>x_2 \leftarrow </math>'''Mutate'''<math>(P)</math> 
'''if'''<math>(H(x_1,x'_1)+H(x_2,x'_2) > H(x_1,x'_2)+H(x_2,x'_1))</math> 
:'''Swap'''<math>(x_1,x'_2)</math> 
'''if''' <math>f(x'_1) > f(x_1)</math> 
: <math>P \leftarrow P \cup x'_1 \setminus x_1</math> 
'''if''' <math>f(x'_2) > f(x_2)</math> 
: <math>P \leftarrow P \cup x'_2 \setminus x_2</math>
|-
|''Termination:''||'''return Best'''<math>(P)</math>
|}

== Задачи ==
====Hierarchical-if-and-only-if function====
'''H-IIF''' – предназначена для моделирования проблемы с блочной структурой, каждый блок которой строго связан с остальными блоками.

:<math>
f(B)= \begin{cases}1,& \mbox{if } |B| = 1, \mbox{ else}
\\|B|+f(B_L)+f(B_R),& \mbox{if }(\forall i \{b_i=0\} \mbox{ or } \forall i \{b_i = 1 \})
\\f(B_L) + f(B_R), & \mbox{otherwise}
\end{cases}
</math>,

где <math>B</math> – блок бит <math>\{b_1,b_2,\dots,b_n \}, |B|</math> – размер блока, а <math>B_L, B_R</math> – левая и правая часть блока соответственно.

Применяя к этой задаче мультиобъективизацию, разобьём задачу <math>f</math> на <math>k</math>-задач.

Представим, как будет выглядеть <math>f(B)</math>:

:<math>
f(B)= \begin{cases}
0, & \mbox{if } |B| = 1 \mbox{ and }b_1 \neq k, \mbox{ else}
\\1,& \mbox{if } |B| = 1 \mbox{ and }b_1 = k, \mbox{ else}
\\|B|+f_k(B_L)+f_k(B_R),& \mbox{if }(\forall i \{b_i=k\},
\\f_k(B_L) + f_k(B_R), & \mbox{otherwise}
\end{cases}
</math>

где <math>f_0(x)</math> – первая цель; <math>f_0(x)</math> – вторая цель.

==== Задача коммивояжера ====
Задача коммивояжера (TSP)является наиболее известно из всего класса <math>NP</math>-сложных задач.
Формулируется задача следующим образом:

Задано <math>C=\{c_1,c_2,\dots,c_N\} </math> – множество городов и для каждой пары <math>\{c_i,c_j\}</math> задано расстояние. Наша цель – найти цепь из городов, минимизирующую величину:
:<math>\sum^{N-1}_{i=1} d(C_{\pi(i)},C_{\pi(i+1)})+d(C_{\pi(N)},C_{\pi(1)})</math>

Применяя к этой задаче мультиобъктивизацию, нужно разбить её на подзадачи. TSP – является <math>NP</math>-сложной именно потому, что нет хорошего разложения этой задачи.
Тем не менее задачу можно разбить на две или больше подтуров, каждый из которых мы можем минимизировать.

Представим подтуры в виде двух городов. Тогда наша задача примет вид:

:<math>minimize\{f(\pi,a,b) = (f_1(\pi,a,b),f_2(\pi,a,b))\}</math>
::'''where'''<math>f_1(\pi,a,b)=\sum^{\pi^{-1}(b)-1}_{i=\pi^{-1}(a)} d(C_{\pi(i)},C_{\pi(i+1)})</math>
::'''and''' <math>f_2(\pi,a,b)=\sum^{N-1}_{i=\pi^{-1}(b)} d(C_{\pi(i)},C_{\pi(i+1)}) + \sum^{\pi^{-1}(a)-1}_{i=1} d(C_{\pi(i)},C_{\pi(i+1)}) </math> <math>+ d(C_{\pi(N)},C_{\pi(1)})</math>,

где <math>a</math> и <math>b</math> – два города, указанных ''априори''. Если <math>\pi (a) < \pi (b)</math>, меняем их местами.

Предполагается, что <math>a</math> и <math>b</math> выбраны произвольно.

== Источники ==
* [http://ru.wikipedia.org/wiki/Многокритериальная_оптимизация Википедия: Многокритериальная оптимизация]
* [http://rain.ifmo.ru/~tsarev/teaching/ea-2012/lectures/3/multiobjectivization.pdf Knowles J., Watson R., Corne D. Reducing Local Optima in Single-Objective Problems by Multi-objectivization]
* [http://en.wikipedia.org/wiki/Multiobjective_optimization Wikipedia: Multiobjective optimization]
* [http://en.wikipedia.org/wiki/Hill_climbing Wikipedia: Hill climbing]

Задача многокритериальной оптимизации. Multiobjectivization

2012-06-20T11:41:32Z

194.85.160.130: /* Введение */

== Введение ==
В данной статье рассматривается многокритериальная оптимизация, её задача. Рассматривается понятие Парето-фронт - множество Парето оптимальных значений. Также рассматривается задача коммивояжера и предлагается алгоритм её мультиобъективизации

== Задача многокритериальной оптимизации ==
=== Постановка задачи ===
{{Определение
|definition=
'''Задача многокритериальной оптимизации:'''
:<math>maximize \{f(x) = (f_1(x),\dots,f_K(x))\}</math>
:<math> x \in X</math>
где <math> f(x) : X \rightarrow R^K</math> – целевая вектор-функция, где <math>K \ge 2</math>
}}
Так как не существует единого решение, которое было бы максимальным для всех целевых функций, вместо него можно искать множество <math>X^* \subseteq X </math> множество Парето оптимальных значений.
=== Множество Парето оптимальных значений ===
{{Определение
|definition=
''' Множество Парето оптимальных значений: '''
:<math>\forall x^* \in X^* \not\exists x \in X </math>:<math>x \succ x^*</math>, где <math>x \succ x^* \Leftrightarrow (\forall i \in 1..K, (f_i(x) \ge f_i(x^*))\land (\exists i \in 1..K, f_i(x) > f_i(x^*)))</math>
}}
Выражение <math>x \succ x^*</math> означает, что <math>x</math> ''доминирует над'' <math>x^*</math>.

Говорят, что <math>x</math> ''доминирует над'' <math>x^*</math>. по
Парето, если <math>x</math> не хуже <math>x^*</math> по всем критериям и хотя бы по одному критерию превосходит <math>x^*</math>.
В таком случае в выборе <math>x^*</math> нет смысла, т.к. <math>x</math> по всем параметрам не уступает, а по каким-то и превосхожит <math>x^*</math>. Если рассматривать всего
два критерия то на рис. 1 показана область
пространства, доминируемая данным решением А. Эта область «замкнута»:
элементы на ее границе также доминируемы А
[[Файл:Dogmin points.jpg|мини|200px|Рис.1 – Доминируемые решения ]]

{{Определение
|definition=
Для двух решений <math>x</math> и <math>x'</math> говорят <math>x \sim x'</math> тогда и только тогда, когда <math>\exists i \in 1..K \colon f_i(x) > f_i(x') \land \exists j \in 1..K, j \ne i \colon f_j(x') > f_j(x)</math> – такую пару решений называют '''недоминируемой'''
}}
На рис. 2 показана граница Парето для
возможных решений в двухкритериальном пространстве
[[Файл:Pareto_front.jpg|мини|200px|Рис.2 – Парето фронт]]
Множество Парето оптимальных недоминируемых решений называется '''Парето фронтом.'''

== Multi-objectivization ==
Суть метода мульти-объективизации заключается в разбитии сложной задачи с одной целевой функцией на несколько подзадач, найти для каждой подзадачи решение и выбрать оптимальное решение.

Для выполнения оптимизации многокритериальной задачи мы должны добавить в целевую функцию новые параметры, либо должны добавить новые целевые функции.

Сложность этой процедуры заключается в разложении проблемы на ряд мелких независимых между собой подпроблем.

== Алгоритмы ==

=== Hill-Climbers ===
{{Определение
|definition=
'''Hill-Climbers''' – Итеративный алгоритм, который начинается с произвольного решения проблемы, а затем пытается найти лучшее решение, постепенно изменяя его. Если изменения позволяют найти лучшее решение, алгоритм сохраняет его и повторяет и повторяет своё выполнение до тех пор, пока лучшие решения не могут быть найдены
}}

{|
|''Initialization:''||<math>P \leftarrow \emptyset </math> '''Init_pop'''<math>(P)</math>
|-
|''Main Loop:''||<math>x_1 \leftarrow </math>'''Rand_mem'''<math>(P)</math>,<math>x'_2 \leftarrow </math>'''Rand_mem'''<math>(P)</math> 
<math>x'_1 \leftarrow </math>'''Mutate'''<math>(P)</math>,<math>x_2 \leftarrow </math>'''Mutate'''<math>(P)</math> 
'''if'''<math>(H(x_1,x'_1)+H(x_2,x'_2) > H(x_1,x'_2)+H(x_2,x'_1))</math> 
:'''Swap'''<math>(x_1,x'_2)</math> 
'''if''' <math>f(x'_1) > f(x_1)</math> 
: <math>P \leftarrow P \cup x'_1 \setminus x_1</math> 
'''if''' <math>f(x'_2) > f(x_2)</math> 
: <math>P \leftarrow P \cup x'_2 \setminus x_2</math>
|-
|''Termination:''||'''return Best'''<math>(P)</math>
|}

== Задачи ==
Задача коммивояжера (TSP)является наиболее известно из всего класса <math>NP</math>-сложных задач.
Формулируется задача следующим образом:

Задано <math>C=\{c_1,c_2,\dots,c_N\} </math> – множество городов и для каждой пары <math>\{c_i,c_j\}</math> задано расстояние. Наша цель – найти цепь из городов, минимизирующую величину:
:<math>\sum^{N-1}_{i=1} d(C_{\pi(i)},C_{\pi(i+1)})+d(C_{\pi(N)},C_{\pi(1)})</math>

Применяя к этой задаче мультиобъктивизацию, нужно разбить её на подзадачи. TSP – является <math>NP</math>-сложной именно потому, что нет хорошего разложения этой задачи.
Тем не менее задачу можно разбить на две или больше подтуров, каждый из которых мы можем минимизировать.

Представим подтуры в виде двух городов. Тогда наша задача примет вид:

:<math>minimize\{f(\pi,a,b) = (f_1(\pi,a,b),f_2(\pi,a,b))\}</math>
::'''where'''<math>f_1(\pi,a,b)=\sum^{\pi^{-1}(b)-1}_{i=\pi^{-1}(a)} d(C_{\pi(i)},C_{\pi(i+1)})</math>
::'''and''' <math>f_2(\pi,a,b)=\sum^{N-1}_{i=\pi^{-1}(b)} d(C_{\pi(i)},C_{\pi(i+1)}) + \sum^{\pi^{-1}(a)-1}_{i=1} d(C_{\pi(i)},C_{\pi(i+1)}) </math> <math>+ d(C_{\pi(N)},C_{\pi(1)})</math>,

где <math>a</math> и <math>b</math> – два города, указанных ''априори''. Если <math>\pi (a) < \pi (b)</math>, меняем их местами.

Предполагается, что <math>a</math> и <math>b</math> выбраны произвольно.

== Источники ==
* [http://ru.wikipedia.org/wiki/Многокритериальная_оптимизация Википедия: Многокритериальная оптимизация]
* [http://rain.ifmo.ru/~tsarev/teaching/ea-2012/lectures/3/multiobjectivization.pdf Knowles J., Watson R., Corne D. Reducing Local Optima in Single-Objective Problems by Multi-objectivization]
* [http://en.wikipedia.org/wiki/Multiobjective_optimization Wikipedia: Multiobjective optimization]
* [http://en.wikipedia.org/wiki/Hill_climbing Wikipedia: Hill climbing]