\documentclass[11pt]{article}

\usepackage{latexsym}
\usepackage{amsmath}
\usepackage{amssymb}
\usepackage{amsthm}
\usepackage{hyperref}
\usepackage{algorithmic}
\usepackage{algorithm}

\newcommand{\handout}[5]{
  \noindent
  \begin{center}
    \framebox{
      \vbox{
        \hbox to 5.78in { {\bf Algebra and Computation } \hfill Course Instructor: #2 }
        \vspace{4mm}
        \hbox to 5.78in { {\Large \hfill #5  \hfill} }
        \vspace{2mm}
        \hbox to 5.78in { {\em #3 \hfill #4} }
      }
    }
  \end{center}
  \vspace*{4mm}
}

\newcommand{\lecture}[4]{\handout{#1}{#2}{Lecturer: #3}{Scribe: #4}{Lecture #1}}

\newtheorem{theorem}{Theorem}
\newtheorem{theorem*}{Theorem}
\newtheorem{corollary}[theorem]{Corollary}
\newtheorem{lemma}[theorem]{Lemma}
\newtheorem{observation}[theorem]{Observation}
\newtheorem{proposition}[theorem]{Proposition}
\newtheorem{definition}[theorem]{Definition}
\newtheorem{claim}[theorem]{Claim}
\newtheorem{fact}[theorem]{Fact}
\newtheorem{subclaim}[theorem]{Subclaim}

% my custom commands
\newcommand{\inparen}[1]{\left(#1\right)}             %\inparen{x+y}  is (x+y)
\newcommand{\inbrace}[1]{\left\{#1\right\}}           %\inbrace{x+y}  is {x+y}
\newcommand{\insquar}[1]{\left[#1\right]}             %\insquar{x+y}  is [x+y]
\newcommand{\inangle}[1]{\left\langle#1\right\rangle} %\inangle{A}    is <A>
\newcommand{\abs}[1]{\left|#1\right|}                 %\abs{x}        is |x|
\newcommand{\norm}[1]{\left\Vert#1\right\Vert}        %\norm{x}       is ||x||
\newcommand{\union}{\cup}
\newcommand{\Union}{\bigcup}
\newcommand{\intersection}{\cap}
\newcommand{\super}[2]{#1^{\inparen{#2}}}             %\super{G}{i-1} is G^{(i-1)}
\newcommand{\setdef}[2]{\inbrace{{#1}\ : \ {#2}}}
\newcommand{\inv}[1]{#1^{-1}}

% Commands specific to this file
% TODO: Find the right way to typeset group index
\DeclareMathOperator{\Sym}{Sym}
\newcommand{\gpidx}[2]{\insquar{#1 : #2}}             %\gpidx{H}{K}   is [H : K]
\newcommand{\gpigs}[2]{\gpidx{\super{G}{#1}}{\super{G}{#2}}} %Group index of g super ...
\newcommand{\llhd}{\!\!\lhd\!\!\lhd}

% \newcommand{\ceil}[1]{\lceil #1 \rceil}
\newcommand{\floor}[1]{\lfloor #1 \rfloor}
% \newcommand{\f}{\mathbb{F}}
% \newcommand{\R}{\mathbb{R}}

%for algorithms
\renewcommand{\algorithmicrequire}{\textbf{Input:}}


\begin{document}

\lecture{5: More on Subgroups and {\sc group-inter}}{V. Arvind}{V.
  Arvind}{Ramprasad Saptharishi}

\section{Overview}

Last lecture we saw that membership in a permutation subgroup can be
done efficiently and inspected the recognizability of some group
properties. This lecture we shall look at other properties of groups
that can be detected efficiently. 

\section{The General Setting}

Over all examples that we have seen, there is a central structure to
all recursive algorithms that we are doing; we want small generating
sets for recursive calls. In general, we are provided a group $G =
\inangle{A}$ and a subgroup $H$ that is only given as a black box, and
we wish to find a generating set for $H$ to inspect its properties.
The general idea was to find a tower of subgroups between $G$ and $H$,
like
$$
G = G_0 \geq G_1 \geq G_2 \geq \cdots \geq G_r = H
$$
and we want certain ``nice'' properties to be satisfied. This can
infact be generalized to non-permutation groups as well. Assume that
our groups are embedded into a larger group, where multiplication,
inverses etc are known.

\begin{enumerate}
\item Given a generating set for $G_i$, we should be able to obtain a
  generating set for $G_{i+1}$ quickly
\item The index $\gpidx{G_i}{G_{i+1}} \leq m$ is not too large
\item Quick membership algorithms in $G_i$
\item A {\sc reduce} procedure to bring down the generating set. 
\end{enumerate}

The {\em quick membership algorithm} requirement has a definition by
its own. 

\begin{definition}
  A group $H$ is said to be polynomial time recognizable if there
  exists a polynomial time algorithm that solves membership in $H$. 
\end{definition}

Though $H$ is not explicitly given, this is a very reasonable
definition. For example, look at $H$ being the automorphism group of
some graph. Finding what $H$ is very unlikely, but certainly given a
permutation of vertices, one can easily check if it is infact an
automorphism or not.\medskip

The properties stated before are precisely what we required for the recursion
to go through. 

\begin{claim}
  With the four properties, we can find a generating set for $H$ quickly
\end{claim}
\begin{proof}
  The first step is to find coset representatives of $H$ in $G$. 
  $$
  G = Hx_1\union Hx_2 \union \cdots \union Hx_r\ \ \ \ r\leq m
  $$
  In the permutation group case, just the orbit of $\inbrace{1}$ would
  have finished it, but what about this case? Note that $G$ acts
  transitively on the set of right cosets! Hence one can find a set of
  unique coset representatives by makign $G$ act on the $id\in G$ and
  checking of two elements $x$ and $y$ of the orbit belong to the same
  coset of $H$ (this happens if and only if $x\inv{y} \in
  H$). 

  Once we have the coset representatives, Schreier's lemma gives a
  generating set for the next element of the tower and recursion
  happens. Crowding of generators around $H$ can be prevented by the
  {\sc reduce} algorithm. Putting them all together, we would have a
  small generating set for $H$. 
\end{proof}

\section{Subnormality and {\sc group-inter}}

\begin{definition}
  A subgroup $H$ of $G$ is said to be subnormal in $G$ if there exists
  a tower of subgroups chained by normality (i.e)
  $$
  H = G_r \lhd G_{r-1} \lhd \cdots \lhd G_0 = G
  $$
  This is denoted by $H\llhd G$.
\end{definition}

\noindent
{\sc subnormal:} Given $H = \inangle{B}$ and $G=\inangle{A}$. Check if
$H\llhd G$. \medskip

The following claim is the core of the algorithm to detect subnormality. 

\begin{claim}
  $H\llhd G \Longleftrightarrow H \llhd \inangle{H^G}$
\end{claim}
\begin{proof}
  One way is obvious, if $H \llhd \inangle{H^G}$, then immediately we
  have the tower $H\llhd \inangle{H^G} \lhd G$.\medskip

  \noindent
  The other direction is also fairly straightforward. Suppose we had a
  tower for $H\llhd G$, 
  $$
  H = G_r \lhd G_{r-1} \lhd \cdots \lhd G_0 = G
  $$
  then clearly, just intersecting the entire tower with the normal
  closure $\inangle{H^G}$, we get
  $$
  H = H\cap \inangle{H^G} \lhd G_{r-1}\cap \inangle{H^G} \lhd \cdots
  \lhd G\cap \inangle{H^G} = \inangle{H^G}
  $$
  which is a tower for $H\llhd \inangle{H^G}$. 
\end{proof}

Hence if $H$ were subnormal, you are guaranteed to find a series
through the normal closure. Hence the algorithm is then immediate:

Compute the normal closure $\inangle{H^G}$. If $\inangle{H^G} = H$,
then we are done since $H \lhd G$ is our tower. If $\inangle{H^G} =
G$, then we know that $H$ cannot be subnormal in $G$ since there is no
way by which you can obtain the tower if $\inangle{H^G} = G$. Hence if
$\inangle{H^G}$ was a strict subgroup of $G$, recurse on this. \medskip

\begin{algorithmic}[1]
\STATE $K_1 = G;\ K_2 = H$
\WHILE{$\inangle{K_2^{K_1}} \neq K_2$}
\IF{$\inangle{K_2^{K_1}} = K_1$}
\STATE {\bf output false}
\ELSE
\STATE $K_1 = \inangle{K_2^{K_1}}$
\ENDIF
\ENDWHILE
\STATE{\bf output true}
\end{algorithmic}

We will now go on to show that if $H\llhd G$, then we can compute
$G\cap H$ efficiently. 

\begin{theorem}
  Let $H = \inangle{B}$ and $G = \inangle{A}$ be subgroups of
  $\Sym_n$. Given the promise that $H\llhd \inangle{G,H}$, we can
  compute a small generating set for $G\cap H$ in polynomial time.
\end{theorem}
\begin{proof}
  Using the subnormality algorithm, we can infact compute the normal
  series of $H$. Let
  \begin{eqnarray*}
    H = G_r \lhd G_{r-1} \lhd &\cdots& \lhd G_0 = \inangle{G,H}\\
    G\cap H \lhd G\cap G_{r-1} \lhd & \cdots & \lhd G\cap G_0 = G\cap
    \inangle{G,H} = G
  \end{eqnarray*}
  Now there are two questions to ask before we apply the recursion
  procedure, is the index between adjacent indices small? Given a
  generating set for $G\cap G_i$, can we find a generating set for
  $G\cap G_{i+1}$?

  As for the second question, note that $G\cap G_i$ normalizes
  $G_{i+1}$! And hence we can use the previous algorithm to get a
  generating set for the intersection $(G\cap G_i)\cap G_{i+1} = G\cap
  G_{i+1}$
  
  As for the first question, exercise! % what is the solution actually?
\end{proof}

\subsection{Recognizing Solvability}

\begin{definition}
  For any group $G$, the commutator subgroup $G'$ of the group, also denoted by
  $\insquar{G,G}$, is defined as 
  $$
  \insquar{G,G} = \setdef{g_1g_2\inv{g_1}\inv{g_2}}{g_1,g_2\in G}
  $$
\end{definition}

Also, it's easy to see that $G'\lhd G$ and $G/G'$ is abelian, infact
it's the smallest group that satisfies this property!

\begin{definition}
  A group $G$ is said to be solvable if we can find a tower
  $$
  G \rhd G_1 \rhd G_2 \rhd \cdots \rhd \inbrace{1}
  $$
  such that for each $i$,  $G_i/G_{i+1}$ is abelian. 
\end{definition}
Equivalently, a group $G$ is solvable if the you can hit $\inbrace{1}$
by looking at successive commutator subgroups. \medskip

\noindent
{\sc solvable:} Given a group $G = \inangle{A}$, check if $G$ is
solvable.\smallskip 

Here's the solution: Take $\insquar{A,A} =
\setdef{a_1a_2\inv{a_1}\inv{a_2}}{a_1, a_2\in A}$ and consider its
normal closure. The claim is that, this is is the commutator subgroup
of $G$! Once we prove this, we can descend by computing successive
normal closures, and if we get stuck, then $G$ can't be solvable.

We leave the proof of the claim and details of this algorithm as an
exercise.
\section{Jerram's Filter}

Recall the {\sc membership} algorithm, the {\sc reduce} procedure was
crucial in keeping the generating set in control through the
recursion. Our algorithm made sure that the generating set does not
grow beyond $n^2$. However, there are much stronger results, and
reduce algorithms. 

\begin{theorem}[Neumann]
  For $n> 3$, every subgroup of $\Sym_n$ can be generated by atmost
  $\floor{\frac{n}{2}}$ elements. 
\end{theorem}
Infact, the above theorem is tight. Consider $\Omega = \inbrace{a_1,
  a_2, \cdots, a_m, b_1, \cdots , b_m}$ and let $G$ be the group
generated by the transpositions $\setdef{(a_i,b_i)}{1\leq i\leq m}$.
This is a generating set for $G$ and has size $\frac{n}{2}$. And since
$G$ is isomorphic to $\mathbb{F}_2^m$, this matches the lower bound as
well.\medskip

However, to algorithmically compute the generators, we need slightly
weaker bound. 

\begin{theorem}[Jerram]
  Any subgroup $G$ of $\Sym_n$ has a generating set of size $(n-1)$.
  Infact, given $G = \inangle{A}$, we can compute an $(n-1)$ sized
  generating set in polynomial time.
\end{theorem}
\begin{proof}
  Define the graph $X_A = \inparen{[n], E_A}$ as follows: For each
  $g\in A$, let $i_g \in [n]$ be the least point moved by $g$. Add the
  edge $e_g = \inparen{i_g, i_g^g}$ to $E_A$.

  We now have an undirected graph on $n$ vertices. We shall go on to
  show that we can keep modifying $A$ to get to get to a graph
  $X_{A'}$ that is acyclic (and of course, $G = \inangle{A'}$), and
  hence the theorem follows. \smallskip

  Before we go into the algorithm, we need one more terminology. For
  any $T\in \Sym_n$, the weight of the graph $X_T$ (denoted by $w(T)$)
  is defined as $\sum_{g\in T} i_g$. An obvious upper bound on $w(T)$
  is $\abs{T}n$. \medskip

  The algorithm is an online algorithm, it maintains a set $A$ such
  that $X_A$ is acyclic and as a new element $g$ comes in, it changes
  $A$ a little to accomodate $g$ and still maintain an acyclic
  graph. \smallskip

  At any stage assume that we have a set $S$ such that $X_S$ is
  acyclic; enter $g$. If even on addition of $e_g$, the graph remains
  acyclic, there is nothing to be done, just add that edge and add $g$
  to the set $S$. 
  
  Otherwise, in $X_{S\union \inbrace{g}}$, there exists a unique cycle
  containing the edge $e_g$. Now each edge of the cycle is labelled
  with an element of $S$ (the direction gives an ambiguity of whether
  it is $g_k$ or $\inv{g_k}$, this will be usually denoted by
  $g_k^{\epsilon}$ where $\epsilon$ can be $1$ or $-1$). 

  Let $i$ be the least point on this cycle. Since $i$ is a part of the
  cycle, one of the two edges incident on $i$ in the cycle must be
  labelled as $g_0$ such that $i = i_{g_0}$. In that direction, walk
  from $i$ round the complete cycle back to $i$; this naturally
  corresponds to a product of the form
  $g_0g_1^{\epsilon_1}g_2^{\epsilon_2}\cdots g_k^{\epsilon_k} = h$.
  Replace $g_0$ by $h$ in the set $S$ (unless $h$ is trivial, in which
  case just discard it).

  Note that this transformation doesn't change the group generated by
  the set, but on the other hand, the choice of $h$ demands that $j^h
  = h$ for all $1\leq j\leq i$ and hence fixes sometime beyond $i$.
  And since we chose $i$ to be the least element of the cycle, the
  weight of the graph increases when we replace $g_0$ by $h$. 

  The size of our set remained the same, but the choice of $h$ forced
  the weight to go up. Hence in a polynomially many steps, we are sure
  to hit the upper bound and hence will end up with an acyclic graph
  (with some $h$ becoming trivial in the process).

  Repeating the process with all elements of $A$, we have a generating
  set $A'$ with an acyclic graph $X_{A'}$, and hence $\abs{A} \leq n-1$.  
\end{proof}

Let us revisit the original {\sc reduce} algorithm that restricted our
generating set to $n^2$, infact that can also be seen in this
setting. In that algorithm, we were looking at collisions and doing
modifications based on that, those precisely correspond to $2$ cycles
in $X_A$. 

Hence Jerram's filter can also be thought of as the original {\sc
  reduce} algorithm but being more mindful about the entire graph
rather than just $2$ cycles. 

\end{document}


