Перестановочные фразы с разбором LR

Фраза перестановки является расширением стандартных (E) определений грамматики без контекста BNF: фраза перестановки содержит произведений (или, что то же самое, нетерминалов) от до . В позиции фразы перестановки мы хотели бы видеть каждое из этих произведений ровно один раз, но нас не интересует порядок этих нетерминалов.$\{ A_1, \dots, A_n \}$$n$$A_1$$A_n$

Например:

S <- X { A, B, C } Y

эквивалентно:

S <- X  A B C  Y
S <- X  A C B  Y
S <- X  B A C  Y
S <- X  B C A  Y
S <- X  C A B  Y
S <- X  C B A  Y

Концепция, кажется, была введена в «Расширение контекстно-свободных грамматик с помощью фраз перестановки» . В нем также описано, как анализировать эти фразы за линейное время, используя анализатор LL (1).

В статье «Разбор фраз перестановки» описан метод разбора фраз перестановки с использованием комбинаторов синтаксического анализа. Это единственные две статьи, которые я нашел, которые говорят о перестановочных фразах и о том, как их анализировать.

Видя, что мы можем легко проанализировать эти типы фраз перестановки с помощью синтаксических анализаторов на основе LL (1), я думаю, что мы можем сделать то же самое с синтаксическими анализаторами стиля LR (1). Поэтому мой вопрос:

Может ли грамматика, содержащая фразы перестановки, быть проанализирована по времени, линейному по размеру входной строки, с использованием механизма LR (1) при сохранении таблицы разумного размера?

$O(|G|!)$

Вышеупомянутый подход работает для любого алгоритма синтаксического анализа (хотя он не полезен), поэтому, возможно, мы можем добиться большего успеха для конкретных алгоритмов. Мы можем уменьшить увеличение до «просто» экспоненциального ( ), кодируя фразы в таблицу LR: мы можем иметь элементы LR, которые кодируют, какие произведения еще предстоит увидеть, и, следовательно, уменьшить увеличение ко всем подмножествам фраз перестановки.$O(2^{|G|})$

Хотя это и лучше, но это, конечно, недостаточно хорошо - фраза перестановки из 30 элементов сделает грамматику непригодной для использования. Есть еще одна часть синтаксического анализа LR, которую мы еще не затронули, и это фактическая основанная на стеке процедура, используемая для синтаксического анализа. Я полагаю, что хранение счетчиков в стеке может решить проблему, но я не уверен, как это сделать.

В настоящее время я реализую генератор синтаксического анализатора, и в проблемной области фразы перестановки будут подарком с небес. Поскольку я использую механизм LR (1), возник следующий вопрос.

Рассматривали ли вы преобразование этого в семантическую проблему? Вместо грамматических правил для всех перестановок нетерминалов {A, B, C}, просто есть одно правило для распознавания (A | B | C) ^ 3 вместе со специальным внутренним кодом, который обеспечивает распознавание только одного из каждого, в противном случае он объявляет ошибка. Я вставил бы пустое произведение перед предложением выше, сокращение которого инициирует инициализацию того, что вы используете для подсчета A, B и C, и одно после, чье сокращение запускает проверку счетчика и (при необходимости) выдает ошибку. (конечно, это может быть немного сложно, если грамматика рекурсивна по A, B и / или C)

Я не думаю, что нужно счетчик. По сути, вы просто проверяете все перестановки, но нарушаете

псевдокод:

perm-match(input, pattern)
     if pattern = nil return true

     foreach(rule in pattern)
         if (match(input, rule))
             perm-match(input - matchedpart, pattern - rule)
             break
         end
     end
     return false
end

Вот более конкретный пример

Предположим, что мы пытаемся сопоставить любую перестановку abcd и наша строка bcda

• Шаг 1: Найдите первый соответствующий символ. В этом случае это б
• Шаг 2: Удалите этот символ из нашего шаблона и уменьшите строку: например, acd и cda остались
• Шаг 3: Повторите шаг 1 для новых строк
  • c соответствует в cda, что оставляет нас с объявлением и да
  • совпадения в да, который оставляет нас с D и D
  • d соответствует d, что оставляет нас с нулем в обеих строках

Итак, вы видите, что этот простой алгоритм может довольно легко проверять перестановку, просто сравнивая «строки» не по порядку. Обратите внимание, что сложность функции O (n!) В худшем случае и O (1) в лучшем случае. В каком-то смысле мы ведем счет, сохраняя символы в массиве. Я бы подумал, что это будет "быстро" в целом, поскольку в большинстве случаев не нужно иметь дело с очень большими n.