Алгоритм Шрайера — Симса

Алгоритм Шрайера — Симса
Граф Кэли группы ${\displaystyle S_{4}}$
Назван в честь	Charles Sim[d] и Отто Шрайер
Автор	Чарльз Симс
Предназначение	Определение порядка группы перестановок
Структура данных	Перестановки
Худшее время	${\displaystyle O(n^{3}m+n^{6})}$

Алгоритм Шрайера — Симса — алгоритм из области вычислительной теории групп, позволяющий после однократного исполнения за линейное время находить порядок группы, порождённой перестановками, проверять принадлежность элемента такой группе и перечислять её элементы. Алгоритм был предложен Чарльзом Симсом в 1970 году для поиска примитивных групп перестановок^[1] и основывается на лемме Шрайера о порождении подгрупп^[2]. Представление группы перестановок, которое находит алгоритм, аналогично ступенчатому виду матрицы для её пространства строк^[3]. Разработанные Симсом методы лежат в основе большинства современных алгоритмов для работы с группами перестановок^[4], модификации алгоритма также используются в современных системах компьютерной алгебры, таких как GAP и Magma^[en][5]. Одним из наиболее наглядных приложений алгоритма является то, что он может быть использован для решения кубика Рубика^[6].

История[править | править код]

Одной из основных задач в теории групп перестановок является поиск групп перестановок заданной степени (то есть минимального числа элементов множества, в группу перестановок которого вкладывается заданная группа перестановок). К 1970 году для степеней от 2 до 11 были найдены все группы перестановок, для степеней от 12 до 15 были найдены все транзитивные группы (то есть подгруппы, действующие на порождающем множестве транзитивно), а для степеней от 16 до 20 были найдены только примитивные группы перестановок^[en]. Для поиска примитивных групп большей степени Чарльз Симс разработал программу, которая находит порядок и некоторую структуру в группе перестановок, заданной своим порождающим множеством^[1].

Оригинальная программа, упомянутая в работе Симса, была написана для IBM 7040^[en] в Ратгерском университете и поддерживала работу с любыми группами, чья степень не превосходила 50^[7]. Точная оценка времени работы алгоритма была впервые проведена Фурстом, Хопкрофтом и Лаксом^[en] в 1980 году^[8]. Время работы было улучшено Джеррумом^[en] в 1982^[9] и Дональдом Кнутом в 1981 году^[10]. В 1980 году была разработана эффективная вероятностная версия алгоритма^[11]. Различные вариации алгоритма, включая те, которые используют вектор Шрайера^[en] вместо дерева орбиты, были разобраны Шерешем^[de] в 2003 году^[12][13].

В вычислительной теории групп алгоритмы над группами перестановок — одна из наиболее развитых областей, и даже сегодня большинство из этих алгоритмов основываются на методах, разработанных Симсом^[4].

Основная идея[править | править код]

Эффективность вычислений с группой перестановок существенно зависит от того, как она задана в программе^[2]. Один из эффективных способов такого задания — выделить ряд её подгрупп и выбрать однозначных представителей смежных классов для каждой подгруппы в этом ряду относительно её предшественника. Предложенный Чарльзом Симсом алгоритм находит ряд подгрупп, в котором каждая следующая группа является стабилизатором предыдущей. Последовательность точек, для которых строятся стабилизаторы, называется базой^[en], а множество, содержащее образующие элементы для каждой группы в ряду, — сильным порождающим множеством^[en][2].

Алгоритм строит базу и сильное порождающее множество для подгруппы перестановок, заданной своим порождающим множеством, используя лемму Шрайера для нахождения порождающих множеств. Размер получаемых на промежуточных шагах множеств растёт экспоненциально, поэтому были разработаны вариации алгоритма, уменьшающие количество рассматриваемых порождающих элементов^[2].

Описанное выше представление разбивает группу в произведение вложенных в неё подмножеств аналогично тому, как ступенчатое представление разбивает векторное пространство в прямую сумму вложенных в него подпространств^[3].

Постановка задачи[править | править код]

Симметрической группой ${\displaystyle S_{n}}$ называют группу, элементами которой являются перестановки элементов некоторого множества ${\displaystyle \Omega }$. Обычно в качестве такого множества берётся ${\displaystyle \Omega =\{1,2,\dots ,n\}}$. В таких обозначениях элементы группы можно рассматривать как отображения ${\displaystyle \sigma :\Omega \to \Omega }$, переводящие множество ${\displaystyle \Omega }$ в себя, то есть его автоморфизмы. Групповой операцией в таких обозначениях является композиция перестановок, для перестановок ${\displaystyle \sigma _{1}}$ и ${\displaystyle \sigma _{2}}$ определяемая как ${\displaystyle \sigma =\sigma _{1}\sigma _{2}}$, где ${\displaystyle \sigma (\omega )=\sigma _{1}(\sigma _{2}(\omega ))}$ для ${\displaystyle \omega \in \Omega }$. Соответственно, единичной перестановкой будет перестановка ${\displaystyle \sigma }$ такая, что ${\displaystyle \sigma (\omega )=\omega }$, а обратная перестановка может быть задана как ${\displaystyle \sigma ^{-1}(\sigma (\omega ))=\omega }$^[14].

Пусть ${\displaystyle S=\{g_{1},\dots ,g_{m}\}\subset S_{n}}$ — множество перестановок длины ${\displaystyle n}$. Порождённой подгруппой множества ${\displaystyle S}$ называют наименьшую по включению подгруппу ${\displaystyle \langle S\rangle }$, которая содержит ${\displaystyle S}$ как подмножество или, что эквивалентно, подгруппу всех элементов ${\displaystyle S_{n}}$, которые могут быть представлены в виде конечного произведения элементов ${\displaystyle S}$ и обратных к ним. Порядком группы перестановок ${\displaystyle S}$ называют число элементов в ней ${\displaystyle |S|}$, а её степенью — мощность множества ${\displaystyle |\Omega |}$, на котором она действует. В таких обозначениях алгоритм должен уметь^[7]:

• Получать порядок ${\textstyle |\langle S\rangle |}$ подгруппы, порождённой данными перестановками,
• По перестановке ${\displaystyle g}$ проверять, лежит ли она в порождённой подгруппе ${\displaystyle \langle S\rangle }$,
• Последовательно перечислять элементы порождённой подгруппы без повторений.

Применения[править | править код]

Модификации алгоритма реализованы в двух наиболее популярных специализированных на вычислительной теории групп системах компьютерной алгебры — GAP и Magma^[en][5]. Инструменты для работы с группами перестановок, включая алгоритмы перечисления смежных классов и алгоритм Шрайера — Симса также представлены в популярных системах более широкого профиля Maple и Mathematica^[15]. Изначально алгоритм был разработан для поиска примитивных групп перестановок заданной степени^[1], однако впоследствии область его применения многократно выросла — например, с помощью данного алгоритма можно находить решения к заданной конфигурации кубика Рубика, так как его вращения образуют группу^[6]. Также алгоритм хорошо показал себя при работе с группами матриц^[en][16].

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

Факторизация группы[править | править код]

Пусть ${\displaystyle H}$ — подгруппа некоторой конечной группы ${\displaystyle G}$, через ${\displaystyle G/H}$ обозначим трансверсаль семейства левых смежных классов ${\displaystyle \{gH:g\in G\}}$. Любой элемент ${\displaystyle g\in G}$ может быть единственным образом представлен как ${\displaystyle g=th}$, где ${\displaystyle t\in G/H}$ и ${\displaystyle h\in H}$. Последовательно применяя этот результат к ${\displaystyle H}$ и её подгруппам, его можно обобщить в следующем виде^[3][17]:

Пусть ${\displaystyle G=G^{(0)}\geq G^{(1)}\geq \dots \geq G^{(k)}=\{e\}}$ — ряд подгрупп ${\displaystyle G}$. Тогда любой элемент ${\displaystyle g\in G}$ может быть единственным образом представлен как ${\displaystyle g=g_{1}g_{2}\dots g_{k}}$, где ${\displaystyle g_{1}\in G^{(0)}/G^{(1)},g_{2}\in G^{(1)}/G^{(2)},\dots ,g_{k}\in G^{(k-1)}/G^{(k)}}$.

Вычисление порядка и перечисление элементов[править | править код]

Описанное выше представление обладает такими свойствами:

• По теореме Лагранжа порядок группы может быть вычислен по формуле ${\textstyle |G|=|G^{(0)}/G^{(1)}|\times |G^{(1)}/G^{(2)}|\times \dots \times |G^{(k-1)}/G^{(k)}|}$^[3],
• Элементы группы можно перечислить, перебирая все возможные представления ${\displaystyle g=g_{1}g_{2}\dots g_{k}}$^[7].

Чтобы также иметь возможность проверять элементы на принадлежность порождённой подгруппе, нужно рассматривать ряды подгрупп особого вида, а именно — составленные из стабилизаторов^[7].

Орбиты и стабилизаторы[править | править код]

Пусть ${\displaystyle G}$ действует на множестве ${\displaystyle \Omega }$. Выберем набор элементов ${\textstyle \omega _{1},\dots ,\omega _{k}\in \Omega }$ и построим ряд подгрупп так, чтобы выполнялось ${\textstyle G^{(i)}=G_{\omega _{i}}^{(i-1)}}$, где ${\displaystyle G_{\omega }=\{g:g\omega =\omega \}}$ — стабилизатор элемента ${\displaystyle \omega }$. Другими словами, ${\textstyle G^{(i)}}$ — это подгруппа элементов ${\displaystyle G}$, которые переводят каждый из элементов ${\textstyle \omega _{1},\dots ,\omega _{i}}$ в себя^[7]. При таком подходе на каждом следующем шаге часть множества ${\displaystyle \Omega }$, на которую нетривиально действует очередная подгруппа ${\displaystyle G}$, будет уменьшаться на один элемент, а порядок подгруппы, с которой ведётся работа, — хотя бы в два раза. Из этого следует, что понадобится ${\displaystyle \min(|\Omega |,\log |G|)}$ итераций алгоритма, прежде чем будет найдено искомое разбиение^[18].

Для построения смежных классов нужно воспользоваться тем, что существует взаимно-однозначное соответствие (биекция) между элементами орбиты ${\displaystyle G\omega }$ и левыми смежными классами ${\textstyle G/G_{\omega }}$ стабилизатора ${\textstyle G_{\omega }}$^[19].

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

По теореме об орбитах и стабилизаторах множество смежных классов ${\displaystyle G/G_{\omega }}$ и орбита ${\displaystyle G\omega }$ равномощны. Сопоставим каждому элементу ${\displaystyle t\in G/G_{\omega }}$ элемент орбиты ${\displaystyle t\omega }$.

Пусть ${\displaystyle t_{1}G_{\omega }=t_{2}G_{\omega }}$, тогда и множества ${\displaystyle (t_{1}G_{\omega })\omega }$ и ${\displaystyle (t_{2}G_{\omega })\omega }$ совпадают. Но из этого следует, что также совпадают ${\displaystyle t_{1}\omega }$ и ${\displaystyle t_{2}\omega }$:

$${\displaystyle t_{1}\omega =t_{1}(G_{\omega }\omega )=(t_{1}G_{\omega })\omega =(t_{2}G_{\omega })\omega =t_{2}(G_{\omega }\omega )=t_{2}\omega }$$

Каждому смежному классу был поставлен в соответствие ровно один элемент орбиты. В силу того, что смежные классы покрывают всю группу ${\displaystyle G}$, все сопоставленные элементы различны. Значит, это действительно биекция. ■

Из доказательства следует, что в качестве представителей смежных классов можно брать элементы, реализующие различные точки орбиты ${\displaystyle G\omega }$^[19].

Проверка принадлежности[править | править код]

Обозначим через ${\displaystyle {\overline {u}}}$ такой элемент ${\displaystyle G/G_{\omega }}$, что ${\displaystyle {\overline {u}}\omega =u}$. Разбиение в ряд стабилизаторов позволит проверять элемент на принадлежность группе^[7]:

• Если ${\displaystyle g\in G^{(i-1)}}$, то найдётся элемент ${\displaystyle t_{i}\in G^{(i-1)}/G^{(i)}}$ такой, что ${\displaystyle g\in t_{i}G^{(i)}}$, то есть ${\displaystyle t_{i}^{-1}g\in G^{(i)}}$,
• В силу биекции между элементами смежного класса и точками орбиты, можно однозначно определить, что ${\displaystyle t_{i}={\overline {g(\omega _{i})}}}$.

Эти свойства позволяют сделать переход от ${\displaystyle G^{(i-1)}}$ к ${\displaystyle G^{(i)}}$, что в итоге приведёт к тому, что текущий элемент должен лежать в ${\displaystyle G^{(k)}=\{e\}}$. Если это действительно так, то ${\displaystyle e=t_{k}^{-1}\dots t_{2}^{-1}t_{1}^{-1}g}$, откуда можно выразить ${\displaystyle g=t_{1}t_{2}\dots t_{k}}$^[7].

Вычисление орбиты[править | править код]

Пусть у группы ${\displaystyle G}$ есть порождающее множество ${\displaystyle S}$. Орбиту любого элемента ${\displaystyle \alpha }$ под действием группы ${\displaystyle G=\langle S\rangle }$ можно организовать в дерево следующего вида^[17]:

• В корне дерева записан некоторый элемент ${\displaystyle \alpha \in \Omega }$,
• В каждой вершине дерева записан некоторый элемент ${\textstyle \beta \in G(\alpha )}$ из орбиты элемента ${\displaystyle \alpha }$,
• На ребре, ведущем из вершины с элементом ${\displaystyle u}$ в вершину с элементом ${\displaystyle v}$, записан элемент ${\displaystyle s\in S}$ такой, что ${\displaystyle s(u)=v}$.

Описанное дерево можно построить обходом в глубину, для этого нужно в каждой вершине ${\displaystyle u}$ перебирать элемент ${\displaystyle s\in S}$, пока не окажется, что для ${\displaystyle s(u)}$ ещё не была выделена вершина^[17]. Пример реализации на языке Python:

# Строит дерево орбиты по заданному элементу w и порождающему множеству S def build_schreier_tree(w, S, orbit):     for g in S:         if g[w] not in orbit:             orbit[g[w]] = apply(g, orbit[w])             build_schreier_tree(g[w], S, orbit) 

Здесь функция ${\displaystyle {\mathsf {apply}}(a,b)}$ возвращает результат применения групповой операции к элементам ${\displaystyle a}$ и ${\displaystyle b}$ в качестве первого и второго аргумента, а в ${\displaystyle {\mathsf {orbit}}[\alpha ]}$ хранится элемент ${\displaystyle {\overline {\alpha }}}$.

Лемма Шрайера[править | править код]

Из леммы Шрайера следует, что стабилизатор ${\displaystyle G_{\alpha }}$ порождается множеством генераторов Шрайера: ${\displaystyle G_{\omega }=\langle \{({\overline {su}})^{-1}s{\overline {u}}\mid u\in G\omega ,s\in S\}\rangle }$. Этот результат позволяет по порождающему множеству для ${\displaystyle G^{(w-1)}}$ и орбите элемента ${\displaystyle \omega }$ построить порождающее множество для ${\displaystyle G^{(\omega )}}$. Возможная реализация для функции, возвращающей новое порождающее множество^[20]:

# Принимает порождающее множество для G_{w-1} и орбиту элемента w # Возвращает порождающее множество для G_w def make_gen(S, orbit):     n = len(next(iter(S)))     newS = set()     for s in S:         for u in orbit:             newS.add(reduce(apply, [inverse(orbit[s[u]]), s, orbit[u]]))     return newS 

Этим алгоритм не исчерпывается, так как хотя размер нового порождающего множества и зависит полиномиально от размера орбиты и старого порождающего множества для одного отдельного вызова, в совокупности по всем вызовам данной функции размер порождающего множества растёт экспоненциально^[2].

Просеивание генераторов[править | править код]

Чтобы избежать неконтролируемого роста порождающих множеств, необходимо применять процедуру просеивания. Для этого потребуется следующее утверждение^[3][20]:

Пусть ${\displaystyle S\subset G}$. Тогда можно построить набор ${\displaystyle S'}$ из не более чем ${\displaystyle \vert \Omega \vert ^{2}}$ элементов такой, что ${\displaystyle \langle S'\rangle =\langle S\rangle }$.

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

Для начала докажем следующую лемму:

Пусть ${\displaystyle S\subset G}$. Тогда следующие преобразования не меняют ${\displaystyle \langle S\rangle }$:

1. Замена ${\displaystyle s\in S}$ на ${\displaystyle s^{-1}}$
2. Замена ${\displaystyle s\in S}$ на ${\displaystyle st}$, где ${\displaystyle t\in S}$ и ${\displaystyle t\neq s}$

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

Пусть после применения одной из этих операций мы получили множество ${\displaystyle S'}$. Очевидно, что ${\displaystyle S'\subset \langle S\rangle }$. С другой стороны, эти преобразования могут быть обращены преобразованиями того же типа, поэтому ${\displaystyle S\subset \langle S'\rangle }$. Значит, ${\displaystyle \langle S\rangle =\langle S'\rangle }$. ■

С помощью таких преобразований мы можем привести множество ${\displaystyle S}$ к такому виду, что для любой пары ${\displaystyle (i,j)}$ в наборе есть не более одного элемента ${\displaystyle s}$ такого, что:

$${\displaystyle s(\omega _{1})=\omega _{1},\ s(\omega _{2})=\omega _{2},\dots ,\ s(\omega _{i-1})=\omega _{i-1},\ s(\omega _{i})=\omega _{j}\neq \omega _{i}}$$

Этого можно добиться, добавляя элементы в новое множество ${\displaystyle S'}$ по одному и действуя аналогично методу Гаусса:

1. Пусть мы хотим добавить в ${\displaystyle S'}$ новый элемент ${\displaystyle s}$,
2. Будем идти по ${\displaystyle \omega _{1},\dots ,\omega _{n}}$ последовательно,
   1. Если ${\displaystyle s(\omega _{i})=\omega _{i}}$, то переходим к ${\displaystyle \omega _{i+1}}$,
   2. Если ${\displaystyle s(\omega _{i})=\omega _{j}}$, то проверяем, встречался ли уже элемент ${\displaystyle t}$ с такой парой ${\displaystyle (i,j)}$,
      1. Если встречался, то заменим ${\displaystyle s}$ на ${\displaystyle s^{-1}t}$ и перейдём к ${\displaystyle \omega _{i+1}}$,
      2. Иначе запомним, что ${\displaystyle s}$ соответствует паре ${\displaystyle (i,j)}$, и добавим ${\displaystyle s}$ в текущем виде в ${\displaystyle S'}$,
3. Если к концу алгоритма мы имеем ${\displaystyle s=e}$, то игнорируем ${\displaystyle s}$ и не меняем ${\displaystyle S'}$.

Данный алгоритм использует только обозначенные выше элементарные операции, поэтому ${\displaystyle \langle S'\rangle =\langle S\rangle }$. Заметим, что если ${\displaystyle s(\omega _{i})=t(\omega _{i})}$, то ${\displaystyle s^{-1}t(\omega _{i})=\omega _{i}}$, поэтому переход к ${\displaystyle \omega _{i+1}}$ от ${\displaystyle s^{-1}t}$ в алгоритме является корректным и каждой паре ${\displaystyle (i,j)}$ действительно соответствует не больше одной перестановки. Учитывая, что всего таких пар не больше ${\displaystyle n^{2}}$, получаем требуемое утверждение.■

Описанная в доказательстве процедура называется фильтром Симса и работает за ${\displaystyle O(|S|\cdot \Omega ^{2})}$^[21]. Её реализация может выглядеть так:

# Принимает порождающее множество S # Возвращает прореженное порождающее множество S' def normalize(S):     n = len(next(iter(S)))     newS = set()     base = [{} for i in range(n)]     for s in S:         for x in range(0, n):             if s[x] != x:                 if s[x] in base[x]:                     s = apply(inverse(s), base[x][s[x]])                 else:                     base[x][s[x]] = s                     newS.add(s)                     break     return newS 

Помимо фильтра Симса для поиска небольшого набора ${\displaystyle S'}$ может использоваться фильтр Джеррума^[22]. В отличие от фильтра Симса, который находит набор из не более, чем ${\displaystyle |\Omega |^{2}}$ элементов, фильтр Джеррума находит набор из не более чем ${\displaystyle |\Omega |}$ элементов. В то же время фильтр Джеррума работает за ${\displaystyle O(|S|\cdot |\Omega |^{4})}$, поэтому в случае алгоритма Шрайера — Симса предпочтительнее использовать именно фильтр Симса^[21].

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

Всё вышенаписанное вместе даёт алгоритм, который может быть лаконично реализован следующим образом^[20]:

# Принимает порождающее множество S = s1, ..., sk # Возвращает трансверсали смежных классов U1, ..., Uk def schreier_sims(S):     n = len(next(iter(S)))     ans = []     w = 0     while S:         orbit = {}         orbit[w] = tuple(range(n))                  build_schreier_tree(w, S, orbit)         ans += [[orbit[i] for i in orbit]]                  S = normalize(make_gen(S, orbit))         w += 1     return ans 

По шагам его действия имеют следующий смысл:

1. Строится орбита элемента ${\displaystyle \omega _{i}}$ поиском в глубину,
2. Вычисляются все генераторы Шрайера для ${\displaystyle G^{(i+1)}}$,
3. Множество генераторов прореживается, чтобы избежать их экспоненциального роста.

На выходе алгоритм вернёт список, элементами которого являются трансверсали смежных классов ${\displaystyle G^{(0)}/G^{(1)},G^{(1)}/G^{(2)},\dots ,G^{(k-1)}/G^{(k)}}$.

Время работы алгоритма[править | править код]

Всего алгоритм требует не больше ${\displaystyle |\Omega |}$ итераций. Каждая итерация состоит из:

1. Построения дерева орбиты, которое занимает ${\displaystyle O(|S|\cdot |\Omega |)}$ элементарных операций,
2. Построения генераторов Шрайера, которое занимает ${\displaystyle O(|S|\cdot |\Omega |^{2})}$ элементарных операций и возвращает ${\displaystyle |S|\cdot |\Omega |}$ генераторов,
3. Нормализации порождающего множества, которое занимает ${\displaystyle O(|S'|\cdot |\Omega |^{2})}$ элементарных операций, где ${\displaystyle S'}$ — множество, полученное на прошлом шаге.

Величина ${\displaystyle |\Omega |}$ в случае, когда дан набор ${\displaystyle S=\{g_{1},\dots ,g_{m}\}\subset S_{n}}$, на протяжении алгоритма не меняется и равна ${\displaystyle n}$. Размер порождающего множество изначально равен ${\displaystyle m}$, а на каждом последующем шаге не превышает ${\displaystyle |\Omega |^{2}=n^{2}}$. Таким образом, общее время работы алгоритма в приведённой реализации можно оценить как ${\displaystyle O(n^{3}m+n^{6})}$^[8][12][13].

Вариации алгоритма[править | править код]

Псевдо-линейные версии[править | править код]

Ранее было показано, что алгоритм требует ${\displaystyle \min(|\Omega |,\log |G|)}$ итераций. В общем случае размер группы может быть порядка ${\displaystyle n!}$, и в таком случае по формуле Стирлинга ${\displaystyle \log |G|\sim n\log n}$, что заведомо больше ${\displaystyle |\Omega |=n}$. Но в некоторых случаях порядок группы небольшой, в связи с чем выгоднее иметь алгоритм, который зависит от ${\displaystyle \log |G|}$, а не ${\displaystyle n}$ — например, когда речь идёт о какой-то известной группе, которая задана как группа перестановок^[12].

По теореме Кэли любая конечная группа изоморфна некоторой группе перестановок. Степень такой группы ${\displaystyle n}$ может быть большой, но для многих групп их порядок ${\displaystyle |G|}$ таков, что ${\displaystyle \log |G|<n}$. Например, диэдральная группа ${\displaystyle D_{n}}$ изоморфна группе перестановок, порождённой циклическим сдвигом ${\displaystyle r=(1~~2~~\dots ~~n)}$ и отражением ${\displaystyle s=(1~~n)(2~~n-1)(3~~n-2)\dots }$. То есть степень данной группы равна ${\displaystyle n}$, а порядок — ${\displaystyle 2n}$, и ${\displaystyle \log |G|\sim \log n}$. Для таких групп можно рассматривать алгоритмы со временем работы ${\displaystyle O(nm\log ^{c}|G|)}$, которые называются псевдо-линейными^[12].

В попытке приблизить алгоритм к псевдо-линейному и снизить степень ${\displaystyle n}$, входящую в его время работы, Шереш пришёл к версиям алгоритма, требующим^[18]:

1. ${\displaystyle O(n^{2}\log ^{3}|G|+mn^{2}\log |G|)}$ времени и ${\displaystyle O(n^{2}\log |G|+mn)}$ памяти,
2. ${\displaystyle O(n^{3}\log ^{3}|G|+mn^{3}\log |G|)}$ времени и ${\displaystyle O(n\log ^{2}|G|+mn)}$ памяти.

Вероятностная версия[править | править код]

Первая рабочая вероятностная версия алгоритма была разработана Джефри Леоном в 1980 году^[11]. Обычно именно её имеют в виду, когда говорят про вероятностный метод Шрайера — Симса. В нём при прореживании генераторов Шрайера данная процедура досрочно прекращалась, если 20 генераторов подряд оказывались разложенными на множители. Шереш показал, что в совокупности с некоторыми оптимизациями эта процедура даёт следующее утверждение^[5]:

Для любой константы ${\displaystyle d}$ существует алгоритм типа Монте-Карло, который с вероятностью ошибки не больше ${\displaystyle n^{-d}}$ построит сильное порождающее множество для группы перестановок ${\displaystyle G=\langle S\rangle }$, используя ${\displaystyle O(n\log n\log ^{4}|G|+mn\log |G|)}$ времени и ${\displaystyle O(n\log |G|+mn)}$ памяти.

В современных системах компьютерной алгебры обычно используются модификации данной версии алгоритма с различными эвристиками для ускорения работы программы^[5].

Примечания[править | править код]

Литература[править | править код]

Эта статья входит в число хороших статей русскоязычного раздела Википедии.