\documentclass[a4paper,11pt]{article}
%\usepackage{showlabels}
\usepackage{amsmath}
\usepackage{amssymb}
\usepackage{amsthm}
\usepackage{amsfonts}
\usepackage{pstricks}
\usepackage{fullpage}

\newtheorem{theorem}{Theorem}[section]
\newtheorem{lemma}[theorem]{Lemma}
\newtheorem{claim}[theorem]{Claim}
\newtheorem{definition}[theorem]{Definition}
\newtheorem{corollary}[theorem]{Corollary}
\newcommand{\GL}[1]{\ensuremath{\mathrm{GL}\left(#1\right)}}
\newcommand{\Sym}[1]{\ensuremath{\mathrm{Sym}\left(#1\right)}}
\newcommand{\Aut}[1]{\ensuremath{\mathrm{Aut}\left(#1\right)}}
\newcommand{\Vertex}[1]{\ensuremath{V\left(#1\right)}}
\newcommand{\Edge}[1]{\ensuremath{E\left(#1\right)}}
\newcommand{\pcyc}{\mathbb{Z}/p\mathbb{Z}}
\usepackage{verbatim}
\begin{document}
\title{Representing groups on graphs}
\author{Sagarmoy Dutta and Piyush P Kurur\\
  Department of Computer Science and Engineering,\\
  Indian Institute of Technology Kanpur,\\
  Kanpur, Uttar Pradesh, India 208016\\
  {\tt \{sagarmoy,ppk\}@cse.iitk.ac.in}
}
\date{}
\maketitle

\begin{abstract}
  In this paper we formulate and study the problem of representing
  groups on graphs. We show that with respect to polynomial time
  turing reducibility, both abelian and solvable group
  representability are all equivalent to graph isomorphism, even when
  the group is presented as a permutation group via generators. On the
  other hand, the representability problem for general groups on trees
  is equivalent to checking, given a group $G$ and $n$, whether a
  nontrivial homomorphism from $G$ to $S_n$ exists.  There does not
  seem to be a polynomial time algorithm for this problem, in spite of
  the fact that tree isomorphism has polynomial time algorithm.
\end{abstract}

\section{Introduction}

Representation theory of groups is a vast and successful branch of
mathematics with applications ranging from fundamental physics to
computer graphics and coding theory \cite{repRealworld}. Recently
representation theory has seen quite a few applications in computer
science as well.  In this article, we study some of the questions
related to representation of finite groups on graphs.

A representation of a group $G$ usually means a linear representation,
i.e. a homomorphism from the group $G$ to the group $\GL{V}$ of
invertible linear transformations on a vector space $V$.  Notice that
$\GL{V}$ is the set of \emph{symmetries} or \emph{automorphisms} of
the vector space $V$. In general, by a representation of $G$ on an
object $X$, we mean a homomorphism from $G$ to the automorphism group
of $X$.  In this article, we study some computational problems that
arise in the representation of \emph{finite groups} on graphs. Our
interest is the following group representability problem: Given a
group $G$ and a graph $X$, decide whether $G$ has a nontrivial
representation on $X$. As expected this problem is closely connected
to graph isomorphism: We show, for example, that the graph isomorphism
problem reduces to representability of abelian groups. In the other
direction we show that even for solvable groups the representability
on graphs is decidable using a graph isomorphism oracle. The
reductions hold true even when the groups are presented as permutation
groups. One might be tempted to conjecture that the problem is
equivalent to Graph Isomorphism. However we conjecture that this might
not be the case. The non-solvable version of this problem seems to be
harder than graph isomorphism. For example, we were able to show that
representability of groups on trees, a class of graphs for which
isomorphism is decidable in polynomial time, is as hard as checking
whether, given an integer $n$ and a group $G$, the symmetric group
$S_n$ has a nontrivial subgroup homomorphic to $G$, a problem for
which no polynomial time algorithm is known.

\section{Background}

In this section we review the group theory required for the rest of
the article. Any standard text book on group theory, for example the
one by Hall~\cite{hall}, will contain the required results.

We use the following standard notation: The identity of a group $G$ is
denoted by $1$. In addition $1$ also stands for the singleton group
consisting of only the identity. For groups $G$ and $H$, $H \leq G$
(or $G\geq H$) means that $H$ is a subgroup of $G$. Similarly by $H
\unlhd G$ (or $G\unrhd H$) we mean $H$ is a \emph{normal subgroup} of
$G$.

Let $G$ be any group and let $x$ and $y$ be any two elements. By the
\emph{commutator} of $x$ and $y$, denoted by $[x,y]$, we mean
$xyx^{-1}y^{-1}$. The \emph{commutator subgroup} of $G$ is the group
generated by the set $\{[x,y]|x,y \in G\}$. We denote the commutator
subgroup of $G$ by $G'$. The following is a well known result in group
theory~\cite[Theorem 9.2.1]{hall}

\begin{theorem}
The commutator subgroup $G'$ is a normal subgroup of $G$ and $G/G'$ is
abelian. Further for any normal subgroup $N$ of $G$ such that $G/N$ is
abelian, $N$ contains $G'$ as a subgroup.
\end{theorem}

A group is \emph{abelian} if it is commutative, i.e. $g h = hg$ for
all group elements $g$ and $h$. A group $G$ is said to be
\emph{solvable}~\cite[Page 138]{hall} if there exists a decreasing
chain of groups $G = G_0 \rhd G_1 \ldots \rhd G_t = 1$ such that
$G_{i+1}$ is the commutator subgroup of $G_i$ for all $0 \leq i < t$.

An important class of groups that play a crucial role in graph
isomorphism and related problems are permutation groups. We follow the
notation of Wielandt~\cite{wielandt64finite} for permutation groups.
Let $\Omega$ be a finite set. The \emph{symmetric group} on $\Omega$,
denoted by $\Sym{\Omega}$, is the group of all permutations on the set
$\Omega$.  By a \emph{permutation group} on $\Omega$ we mean a
subgroup of the symmetric group $\Sym{\Omega}$. For any positive
integer $n$, we will use $S_n$ to denote the symmetric group on
$\{1,\ldots, n\}$. Let $g$ be a permutation on $\Omega$ and let
$\alpha$ be an element of $\Omega$. The image of $\alpha$ under $g$
will be denoted by $\alpha^g$. For a permutation group $G$ on
$\Omega$, the orbit of $\alpha$ is denoted by $\alpha^G$. Similarly if
$\Delta$ be a subset of $\Omega$ then $\Delta^g$ denotes the set $\{
\alpha^g | \alpha \in \Delta \}$.

Any permutation group $G$ on $n$ symbols has a generating set of size
at most $n$. Thus for computational tasks involving permutation groups
it is assumed that the group is presented to the algorithm via a small
generating set. As a result, by efficient algorithms for permutation
groups on $n$ symbols we mean algorithms that take time polynomial in
the size of the generating set and $n$.

Let $G$ be a subgroup of $S_n$ and let $G^{(i)}$ denote the subgroup
of $G$ that fixes pointwise $j \leq i$, i.e. $G^{(i)} = \{ g | j^g =
j, 1 \leq j \leq i \}$. Let $C_i$ denote a right \emph{transversal},
i.e.  the set of right coset representative, for $G^{(i)}$ in
$G^{(i-1)}$. The $\cup_i C_i$ is a generating set for $G$ and is
called the \emph{strong generating set} for $G$. The corner stone for
most polynomial time algorithms for permutation group is the
Schreier-Sims~\cite{sims70computational,sims78some,furst80polynomialtime}
algorithm for computing the \emph{strong generating set} of a
permutation group $G$ given an arbitrary generating set. Once the
strong generating set is computed, many natural problems for
permutation groups can be solved efficiently. We give a list of them
in the next theorem.

\begin{theorem}\label{thm-perm-polytime}
  Given a generating set for $G$ there are polynomial time algorithms
  for the following task.
  \begin{enumerate}
  \item Computing the strong generating set.
  \item Computing the order of $G$.
  \end{enumerate}
\end{theorem}

By a graph we mean a \emph{finite undirected graph}. For a graph $X$,
$\Vertex{X}$ and $\Edge{X}$ denotes the set of vertices and edges
respectively and $\Aut{X}$ denotes the group of all
automorphisms of $X$, i.e. permutations on $\Vertex{X}$ that maps
edges to edges and non-edges to non-edges.

\begin{definition}[Representation]
  A representation $\rho$ from a group $G$ to a graph $X$ is a
  homomorphism from $G$ to the automorphism group $\Aut{X}$ of $X$.
\end{definition}

Alternatively we say that $G$ acts on (the right) of $X$ via the
representation $\rho$. When $\rho$ is understood, we use $u^g$ to
denoted $u^{\rho(g)}$.

A representation $\rho$ is \emph{trivial} if all the elements of $G$
are mapped to the identity permutation. A representation $\rho$ is
said to be \emph{faithful} if it is an injection as well. Under a
faithful action $G$ can be thought of as a subgroup of the
automorphism group. We say that $G$ is \emph{representable} on $X$
 if there is a nontrivial representation from $G$ to
$X$. We now define the following natural computational problem.

\begin{definition}[Group representability problem]
  Given a group $G$ and a graph $X$ decide whether $G$ is
  representable on $X$ nontrivially.
\end{definition}

We will look at various restrictions of the above problem. For example,
we study the abelian (solvable) group representability problem where
our input groups are abelian (solvable). We also study the group
representability problem on trees, by which we mean group
representability where the input graph is a tree.

Depending on how the group is presented to the algorithm, the
complexity of the problem changes. One possible way to present $G$ is
to present it as a permutation group on $m$ symbols via a generating
set. In this case the input size is $m + \# V(X)$. On the other hand,
we can make the task of the algorithm easier by presenting the group
via a multiplication table. In this paper we mostly assume that the
group is in fact presented via its multiplication table. Thus
polynomial time means polynomial in $\# G$ and $\# V(X)$. However for
solvable representability problem, our results extend to the case when
$G$ is a permutation group presented via a set of generators.

We now look at the following closely related problem that occurs
when we study the representability of groups on trees.

\begin{definition}[Permutation representability problem]
  \label{def-perm-representability}
  Given a group $G$ and an integer $n$ in unary, check whether there is
  a homomorphism from $G$ to $S_n$.
\end{definition}

\subsection*{Overview of the results}

Our first result is to show that graph isomorphism reduces to abelian
representability problem. In fact we show that graph isomorphism
reduces to the representability of prime order cyclic groups on
graphs. Next we show that solvable group representability problem
reduces to graph isomorphism problem. Thus as far as polynomial time
Turing reducibility is concerned abelian group representability and
solvable group representability are all equivalent to graph
isomorphism. As a corollary we have, solvable group representability on
say bounded degree graphs or bounded genus graphs are all in
polynomial time.

We then show that group representability on trees is equivalent to
permutation representability
(Definition~\ref{def-perm-representability}). This is in contrast to
the corresponding isomorphism problem because for trees, isomorphism
testing is in polynomial time whereas permutation representability
problem does not appear to have a polynomial time algorithm.

\section{Abelian representability}

In this section we prove that the graph isomorphism problem reduces to
abelian group representability on graph. Given input graphs $X$ and
$Y$ of $n$ vertices each and any prime $p > n$, we construct a graph
$Z$ of exactly $p \cdot n$ vertices such that $X$ and $Y$ are
isomorphic if and only if the cyclic group of order $p$ is
representable on $Z$. Since for any integer $n$ there is a
prime $p$ between $n$ and $2n$ (Bertrand's conjecture), the above
constructions gives us a reduction from the graph isomorphism problem
to abelian group representability problem.

For the rest of the section, fix the input graphs $X$ and $Y$. Our
task is to decide whether $X$ and $Y$ are isomorphic.  Firstly we
assume, without loss of generality, that the graphs $X$ and $Y$ are
connected, for otherwise we can take their complement graphs $X'$ and
$Y'$, which are connected and are isomorphic if and only if $X$ and
$Y$ are isomorphic. Let $n$ be the number of vertices in $X$ and $Y$
and let $p$ be any prime greater than $n$. Consider the graph $Z$
which is the disjoint union of $p$ connected components
$Z_1,\ldots,Z_p$ where, for each $1 \leq i < p$, each $Z_i$ is an
isomorphic copy of $X$ and $Z_p$ is an isomorphic copy of $Y$. First
we prove the following lemma.

\begin{lemma}\label{lem-gigrepf}
  If $X$ and $Y$ are isomorphic then $\pcyc$ is representable
  on $Z$.
\end{lemma}
\begin{proof}
  Clearly it is sufficient to show that there is an order $p$
  automorphism for $Z$. Let $h$ be an isomorphism from $X$ to $Y$. For
  every vertex $v$ in $X$, let $v_i$ denote its copy in
  $Z_i$. Consider the bijection $g$ from $V(Z)$ to itself defined as
  follows: For all vertices $v$ in $V(X)$ and each $1 \leq i < p - 2$,
  let $v_i^g = v_{i+1}$. Further let $g$ map $v_{p-1}$ to $v^h$ and
  $v^h$ to $v_1$. It is easy to verify that $g$ is an automorphism of
  $Z$ and has order $p$.
\end{proof}

We now prove the converse
\begin{lemma}\label{lem-gigrepb}
  If $\pcyc$ can be represented on $Z$ then $X$ and $Y$ are
  isomorphic.
\end{lemma}
\begin{proof}
  If $\pcyc$ can be represented on $Z$ then there exists a nonidentity
  automorphism $g$ of $Z$ such that order of $g$ is $p$. We consider
  the action of the cyclic group $H$, generated by $g$, on $V(X)$. Since
  $g$ is nontrivial, there exists at least one $H$-orbit $\Delta$ of
  $V(X)$ which is of cardinality greater than $1$. However by orbit
  stabiliser formula \cite[Theorem 3.2]{wielandt64finite}, $\# \Delta$
  divides $\# H = p$. Since $p$ is prime, $\Delta$ should be of
  cardinality $p$.

  We prove that no two vertices of $\Delta$ belong to the same
  connected component. Assume the contrary and let $\alpha$ and
  $\beta$ be two elements of $\Delta$ which also belong to the same
  connected component of $Z$. There is some $0 < t < p$ such that
  $\alpha^{g^t} = \beta$. We assume further, without loss of
  generality, that $t=1$, for otherwise we replace $g$ by the
  automorphism $g^t$, which is also of order $p$, and carry out the
  argument. Therefore $\alpha^g = \beta$ lie in the same component of
  $Z$. It follows then that, for each $0 \leq i \leq p -1 $, the element
  $\alpha_i = \alpha^{g^i}$ is in the same component of $Z$, as
  automorphisms preserve edges and hence paths. However this means
  that there is a component of $Z$ that is of cardinality at least
  $p$. This is a contradiction as each component of $Z$ has at most $n
  < p$ vertices as they are copies of either $X$ or $Y$.

  It follows that there is some $1 \leq i < p$, for which $g$ must map
  at least one vertex of the component $Z_i$ to some vertex of
  $Z_p$. As a result the automorphism $g$ maps the entire component
  $Z_i$ to $Z_p$.  Therefore the components $Z_i$ and $Z_p$ are
  isomorphic and so are their isomorphic copies $X$ and $Y$.
\end{proof}

Given two graphs $X$ and $Y$ of $n$ vertices we find a prime $p$ such
that $n < p < 2n$, construct the graph $Z$ and construct the
multiplication table for $\pcyc$. This requires only logarithmic space
in $n$. Using Lemmas~\ref{lem-gigrepf} and \ref{lem-gigrepb} we have
the desired reduction.

\begin{theorem}
  The graph isomorphism problem logspace many-one reduces to abelian
  group representability problem.
\end{theorem}

\section{Solvable representability problem}

In the previous section we proved that abelian group representability
is at least as hard as graph isomorphism. In this section we show that
solvable group representability is polynomial time Turing reducible to
the graph isomorphism problem. We claim that a solvable group $G$ is
representable on $X$ if and only if $\# \Aut{X}$ and $\# G/G'$ have a
common prime factor, where $G'$ is commutator subgroup of $G$. We do
this in two stages.

\begin{lemma}\label{lem-solf}
  A solvable group $G$ can be represented on a graph $X$ if $\#G/G'$
  and $\#\Aut{X}$ have a common prime factor.
\end{lemma}
\begin{proof}

Firstly notice that it suffices to prove that there is a nontrivial
homomorphism, say $\rho$, from $G/G'$ to $\Aut{X}$. A nontrivial
representation for $G$ can be obtained by composing the natural
quotient homomorphism from $G$ \emph{onto} $G/G'$ with $\rho$.

Recall that the quotient group $G/G'$ is an abelian group and hence
can be represented on $X$ if for some prime $p$ that divides $\#
G/G'$, there is an order $p$ automorphism for $X$. However by the
assumption of the theorem, there is a common prime factor, say $p$, of
$\# G/G'$ and $\# \Aut{X}$. Therefore, by Cayley's theorem there is an
order $p$ element in $\Aut{X}$. As a result, $G/G'$ and hence $G$ is
representable on $X$.
\end{proof}

To prove the converse, for the rest of the section fix the input, the
solvable group $G$ and the graph $X$. Consider any nontrivial
homomorphism $\rho$ from the group $G$ to $\Aut{X}$. Let $H \leq
\Aut{X}$ denote the image of the group $G$ under $\rho$. We will from
now on consider $\rho$ as an automorphism from $G$ \emph{onto}
$H$. Since the subgroup $H$ is the homomorphic image of $G$, $H$
itself is a solvable group.

\begin{lemma}\label{comm}
The homomorphism $\rho$ maps the commutator subgroup $G'$ of $G$
\emph{onto} the commutator subgroup $H'$.
\end{lemma}
\begin{proof}
  First we prove that $\rho(G') \leq H'$. For this notice that for all
  $x$ and $y$ in $G$, since $\rho$ is a homomorphism, $\rho([x,y]) =
  [\rho(x),\rho(y)]$ is an element of $H'$. As $G'$ is generated by
  the set $\{ [x,y] | x,y \in G\}$ of all commutators, $\rho(G') \leq
  H'$.  To prove the converse notice that $\rho$ is a surjection on
  $H$.  Therefore for any element $h$ of $H$, we have element $x_h$ of
  $G$ such that $\rho(x_h) = h$. Consider the commutator $[g,h]$ for
  any two elements $g$ and $h$ of $H$. We have $\rho([x_g,x_h]) =
  [g,h]$.  This proves that all the commutators of $H$ are in the
  image of $G'$ and hence $\rho(G') \geq H'$.
\end{proof}

We have the following result about solvable groups that directly
follows from the definition of solvable groups \cite[Page 138]{hall}.

\begin{lemma}\label{lem-nontrivial-govergprime}
  Let $G$ be any nontrivial solvable group then its commutator
  subgroup $G'$ is a strict subgroup of $G$.
\end{lemma}
\begin{proof}
  By the definition of solvable groups, there exist a chain $G = G_0
  \rhd G_1 \ldots \rhd G_t = 1$ such that $G_{i+1}$ is the commutator
  subgroup of $G_i$ for all $0 \leq i < t$. If $G=G'=G_1$ then $G=G_i$
  for all $0 \leq i \leq t$ implying $G=1$
\end{proof}

We are now ready to prove the converse of Lemma~\ref{lem-solf}.

\begin{lemma}\label{lem-solb}
  Let $G$ be any solvable group and let $X$ be any graph. The orders
  $\#G/G'$ and $\#\Aut{X}$ have a common prime factor if $G$ is
  representable on graph $X$.
\end{lemma}
\begin{proof}
  Let $\rho$ be any nontrivial homomorphism from $G$ to $\Aut{X}$, and
  let $H$ be the image of group $G$ under this homomorphism. Since the
  commutator subgroup $G'$ is strictly contained in the group $G$
  (Lemma~\ref{lem-nontrivial-govergprime}), order of the quotient
  group $\#G/G' >1$. Furthermore, the image group $H$ itself is
  solvable and nontrivial, as it is the image of a solvable group $G$
  under a nontrivial homomorphism. Therefore, the commutator subgroup
  $H'$ is strictly contained in $H$ implying $\#H/\#H'>1$.

  Consider the homomorphism $\tilde{\rho}$ from $G$ \emph{onto} $H/H'$
  defined as $\tilde{\rho}(g) = \rho(g) H'$. Since $\rho$ maps $G'$
  onto $H'$, we have that $G'$ is in the kernel of
  $\tilde{\rho}$. Therefore, $\tilde{\rho}$ can be \emph{refined} to a
  map from $G/G'$ \emph{onto} $H/H'$. Clearly the prime factors of $\#
  H/H'$ are all prime factors of $\# G/G'$. However, any prime factor
  of $\# H/H'$ is a prime factor of $\Aut{X}$, as both $H$ and $H'$
  are subgroups of $\Aut{X}$. Therefore, the orders of $G/G'$ and
  $\Aut{X}$ have a common prime factor.
\end{proof}

The order of the automorphism group of the input graph $X$ can be
computed in polynomial time using an oracle to the graph isomorphism
problem~\cite{mathon79note}. Further since the automorphism group is a
subgroup of $S_n$, where $n$ is the cardinality of $V(X)$, all its
prime factors are less than $n$ and hence can be determined. Also
since $G$ is given as a table, its commutator subgroup $G'$ can be
computed in polynomial time and the prime factors of $\# G/G'$ can
also be similarly determined.  Therefore we can easily check, given
the group $G$ via its multiplication table and the graph $X$, whether
the order of the quotient group $G/G'$ has common factors with the
order of $\Aut{X}$. We thus have the following theorem.

\begin{theorem}\label{thm-solvable-to-gi}
  The problem of deciding whether a solvable group can be represented
  on a given graph reduces to graph isomorphism problem.
\end{theorem}

For the reduction in the above theorem to work, it is sufficient to
compute the order of $G$ and its commutator subgroup $G'$. This can be
done even when the group $G$ is presented as a permutation group on
$m$ symbols via a generating set. To compute $\# G$ we can compute the
strong generating set of $G$ and use
Theorem~\ref{thm-perm-polytime}. Further given a generating set for
$G$, a generating set for its commutator subgroup $G'$ can be compute
in polynomial time~\cite[Theorem 4]{furst80polynomialtime}. Therefore,
the order of $G/G'$ can be computed in polynomial time given the
generating set for $G$. Furthermore, $G$ and $G'$ are subgroups of
$S_m$ and hence all their prime factors are less than $m$ and can
be determined. We can then check whether $\# G/G'$ has any common
prime factors with $\# \Aut{X}$ just as before using the graph isomorphism
oracle. Thus we have the following theorem.

\begin{theorem}
  The solvable group representability problem, where the group is
  presented as a permutation group via a generating set, reduces to
  the graph isomorphism problem via polynomial time Turing reduction.
\end{theorem}

\section{Representation on tree}\label{sect-tree-representability}

In this section we study the representation of groups on trees. It is
known that isomorphism of trees can be tested in polynomial
time~\cite{babai83canonical}. However we show that the group
representability problem over trees is equivalent to permutation
representability problem (Definition~\ref{def-perm-representability}),
a problem for which, we believe, there is no polynomial time
algorithm.

Firstly, to show that permutation representability problem is
reducible to group representability problem on trees, it is sufficient
to construct, given and integer $n$, a tree whose automorphism group
is $S_n$. Clearly a tree with $n$ leaves, all of which is connected to
the root, gives such a tree (see
Figure~\ref{fig-tree-with-sn}). Therefore we have the following lemma.
\begin{lemma}\label{lemsn2tree}
Permutation representability reduces to representability on tree.
\end{lemma}

\begin{figure}[h!]
\begin{center}
\begin{pspicture}(3,1.3)
%\psgrid
\psline{*-*}(1.5,1.2)(0.1,0.1)
\psline{-*}(1.5,1.2)(0.7,0.1)
\psline{-*}(1.5,1.2)(1.3,0.1)
\psline{-*}(1.5,1.2)(2.9,0.1)
\rput(1.8,0.1){$\ldots$}
\end{pspicture}
\end{center}
\caption{Tree with automorphism group $S_n$}\label{fig-tree-with-sn}
\end{figure}

To prove the converse, we first reduce the group representability
problem on an arbitrary tree to the problem of representability on a
rooted tree. We then do a divide and conquer on the structure of the
rooted tree using the permutation representability oracle. The main
idea behind this reduction is Lemma~\ref{lem-edge} where we show that for any
tree $T$, either there is a vertex which is fixed by all automorphism,
in which case we can choose this vertex as the root, or there are two
vertices $\alpha$ and $\beta$ connected by an edge which together
forms an orbit under the action of $\Aut{T}$, in which case we can add
a dummy root (see Figure~\ref{fig-maximal-orbit}) to make it a rooted
tree without changing the automorphism group.

\begin{figure}[h!]
\begin{center}
\begin{pspicture}(9,2.2)
%\psgrid
\psline{*-*}(1,1.4)(3,1.4)
\pspolygon(1,1.4)(0.3,0.1)(1.7,0.1)
\pspolygon(3,1.4)(2.3,0.1)(3.7,0.1)
\rput[b](1,1.5){$\alpha$} \rput[b](3,1.5){$\beta$}
\psline{*-*}(6,1.4)(7,1.8)
\psline{-*}(7,1.8)(8,1.4)
\pspolygon(6,1.4)(5.3,0.1)(6.7,0.1)
\pspolygon(8,1.4)(7.3,0.1)(8.7,0.1)
\rput[b](6,1.5){$\alpha$} \rput[b](8,1.5){$\beta$} \rput[b](7,1.9){$\gamma$}
\end{pspicture}
\end{center}
\caption{Minimal orbit has two elements}\label{fig-maximal-orbit}
\end{figure}

For the rest of the section fix a tree $T$.  Let $\Delta$ be an orbit
in the action of $\Aut{T}$ on $V(T)$.  We define the graph $T_\Delta$
as follows: A vertex $\gamma$ (or edge $e$) of $T$ belongs to
$T_\Delta$ if there are two vertices $\alpha$ and $\beta$ in $\Delta$
such that $\gamma$ (or $e$) is contained in the path from $\alpha$ to
$\beta$. It is easy to see that $T_\Delta$ contains paths between any
two vertices of $\Delta$. Any vertex in $T_{\Delta}$ is connected to
some vertex in $\Delta$ and all vertices in $\Delta$ are connected in
$T_{\Delta}$ which implies $T_{\Delta}$ is connected. Furthermore
$T_\Delta$ has no cycle, as its edge set is a subset of the edge set
of $T$. Therefore $T_\Delta$ is a tree.

\begin{lemma}
  Let $g$ be any automorphism of $T$ and consider any vertex $\gamma$
  (or edge $e$) of $T_\Delta$. Then the vertex $\gamma^g$ (or edge
  $e^g$) is also in $T_\Delta$.
\end{lemma}
\begin{proof}
  Since $\gamma$ (or $e$) is present in $T_\Delta$, there exists
  $\alpha$ and $\beta$ in $\Delta$ such that $\gamma$ (or $e$) is in
  the path between $\alpha$ and $\beta$. Also since automorphisms
  preserve paths, $\gamma^g$ (or $e^g$) is in the path from
  $\alpha^g$ to $\beta^g$.
\end{proof}

\begin{lemma}\label{lemleaf}
  The orbit $\Delta$ is precisely the set of leaves of $T_{\Delta}$.
\end{lemma}
\begin{proof}
  First we show that all leaf nodes of $T_{\Delta}$ are in orbit
  $\Delta$. Any node $\alpha$ of $T_{\Delta}$ must lie on a path such
  that the endpoints are in orbit $\Delta$. If $\alpha$ is a leaf of
  $T_{\Delta}$, this can only happen when $\alpha$ itself is in
  $\Delta$.

  We will prove the converse by contradiction. If possible let
  $\alpha$ be a vertex in the orbit $\Delta$ which is not a leaf of
  $T_{\Delta}$. Vertex $\alpha$ must lie on the path between two
  leaves $\beta$ and $\gamma$. Also since $\beta$ and $\gamma$ are
  leaves of $T_\Delta$, they are in the orbit $\Delta$.

  Let $g$ be an automorphism of $T$ which maps $\alpha$ to $\beta$.
  Such an automorphism exists because $\alpha$ and $\beta$ are in the
  same orbit $\Delta$. The image $\alpha^g=\beta$ must lie on the path
  between $\beta^g$ and $\gamma^g$ and neither $\beta^g$ or $\gamma^g$
  is $\beta$. This is impossible because $\beta$ is a leaf of
  $T_\Delta$.
\end{proof}

\begin{lemma}\label{lem-subtree}
  Let $\gamma$ be a vertex in orbit $\Sigma$. If $\gamma$ is a vertex
  of the subtree $T_{\Delta}$ then subtree $T_{\Sigma}$ is a subtree
  of $T_{\Delta}$.
\end{lemma}
\begin{proof}
  Assume that $\Delta$ is different from $\Sigma$, for otherwise the
  proof is trivial. First we show that all the vertices of $\Sigma$
  are vertices of $T_\Delta$. The vertex $\gamma$ lies on a path
  between two vertices of $\Delta$, say $\alpha$ and $\beta$. Take any
  vertex $\gamma'$ from the orbit $\Sigma$. There is an automorphism
  $g$ of $T$ which maps $\gamma$ to $\gamma'$. Now $\gamma'=\gamma^g$
  lies on the path between $\alpha^g$ and $\beta^g$ and hence is in
  the tree $T_\Delta$.

  Consider any edge $e$ of $T_\Sigma$. There exists $\gamma_1$ and
  $\gamma_2$ of $\Sigma$ such that $e$ is on the path from $\gamma_1$
  to $\gamma_2$. By previous argument, $T$ contains $\gamma_1$ and
  $\gamma_2$. Since $T$ is a tree, this path is unique and any
  subgraph of $T$, in which $\gamma_1$ and $\gamma_2$ are connected,
  must contain this path. Hence $T_{\Delta}$ contains $e$.
\end{proof}

\begin{lemma}\label{lem-edge}
  Let $T$ be any tree then either there exists a vertex $\alpha$ that
  is fixed by all the automorphisms of $T$ or there exists two
  vertices $\alpha$ and $\beta$ connected via an edge $e$ such that
  $\{ \alpha,\beta\}$ is an orbit of $\Aut{T}$. In the latter case
  every automorphism maps $e$ to itself.
\end{lemma}

%% \begin{proof}[Proof of lemma \ref{lemedge}]
%% First we prove the existence of such an orbit. Take any vertex
%% $\alpha$ belonging to orbit $\Delta$. If $T_{\Delta}$ has more than 2
%% vertices then there must be a nonleaf $\beta$ in $T_{\Delta}$. Let
%% $\Sigma$ be the orbit of $\beta$. Lemma \ref{lemleaf} ensures that
%% $\Delta\not=\Sigma$ and by lemma \ref{lemsubtree} $T_{\Sigma}$ is
%% proper subtree of $T_{\Delta}$. Thus we can continue constructing
%% smaller and smaller subtrees until it has less than vertices. Since
%% each orbit contains more than one vertices, there is an orbit such
%% that the corresponding subtree has 2 leaves and an edge between them.

%% Now we show that there is only one such orbit. If possible let there
%% be two such orbit $\{\alpha,\alpha'\}$ and $\{\beta,\beta'\}$. Without
%% loss of generality let us assume that the path between $\alpha$ and
%% $\beta$ does not contain $\alpha'$ or $\beta'$, otherwise could choose
%% $\alpha'$ or $\beta'$ instead of $\alpha$ or $\beta$
%% respectively. There is an automorphism $g$ of $T$ which maps $\alpha$
%% to $\alpha'$. The same automorphism also maps $\beta$ to either
%% $\beta'$ or $\beta$ itself. Now since the paths from $\alpha'$ to
%% $\beta$ or $\beta'$ must pass through $\alpha$, the path length of
%% between $\alpha^g$ and $\beta^g$ is more than the path length between
%% $\alpha$ and $\beta$. But, since $g$ is an automorphism, the
%% pathlengths must be same. Hence we have a contradiction.
%% \end{proof}

\begin{proof}
  Consider the following partial order between orbits of $\Aut{T}$:
  $\Sigma \leq \Delta$ if $T_\Sigma$ is a subtree of $T_\Delta$. The
  relation $\leq$ is clearly a partial order because the ``subtree''
  relation is.  Since there are finitely many orbits there is always a
  minimal orbit under the above ordering.  From Lemmas~\ref{lemleaf}
  and \ref{lem-subtree} it follows that for an orbit $\Delta$, if
  $\Sigma$ is the orbit containing an internal node $\gamma$ of
  $T_\Delta$ then $\Sigma$ is strictly less than $\Delta$. Therefore
  for any minimal orbit $\Delta$, all the nodes are leaves. This is
  possible if either $T_\Delta$ is a singleton vertex $\alpha$, or
  consists of exactly two nodes connected via an edge. In the former
  case all automorphisms of $T$ have to fix $\alpha$, whereas in the
  latter case the two nodes may be flipped but the edge connecting
  them has to be mapped to itself.
\end{proof}

It follows from Lemma~\ref{lem-edge} that any tree $T$ can be rooted,
either at a vertex or at an edge with out changing the automorphism.
Given a tree $T$, since computing the generating set for $\Aut{T}$ can
be done in polynomial time, we can determine all the orbits of
$\Aut{T}$ by a simple transitive closure algorithm. Having computed
these orbits, we determine whether $T$ has singleton orbit or an orbit
of cardinality $2$. For trees with an orbit containing a single vertex
$\alpha$, rooting the tree at $\alpha$ does not change the
automorphism group. On the other hand if the tree has an orbit with
two elements we can add a dummy root as in
Figure~\ref{fig-maximal-orbit} without changing the automorphism
group. Since by Lemma~\ref{lem-edge} these are the only two
possibilities we have the following theorem.

\begin{theorem}
  There is a polynomial time algorithm that, given as input a tree $T$,
  outputs a rooted tree $T'$ such that for any group $G$, $G$ is
  representable on $T$ if and only if $G$ is representable on the rooted tree
  $T'$.
\end{theorem}

For the rest of the section by a tree we mean a rooted tree. We will
prove the reduction from representability on rooted trees to
permutation representability. First we characterise the automorphism
group of a tree in terms of wreath product [Theorem \ref{thmtreeauto}]
and then show that we can find a nontrivial homomorphism, if there
exists one, from the given group $G$ to this automorphism group by
querying a permutation representability oracle.

\begin{definition}[Semidirect product and wreath product]
  Let $G$ and $A$ be any two group and let $\varphi$ be any
  homomorphism from $G$ to $\Aut{A}$, then the semi-direct product
  $G\ltimes_\varphi A$ is the group whose underlying set is $G\times
  A$ and the multiplication is defined as $(g,a) (h,b) = (gh,
  a^{\varphi(h)}b)$.

  We use $W_n(A)$ to denote the wreath product $S_n \wr A$ which is
  the semidirect product $S_n\ltimes_\varphi A^n$, where $A^n$ is the
  $n$-fold direct product of $A$ and ${\varphi(h)}$, for each $h$ in
  $S_n$, permutes $\mathbf{a} \in A^n$ according to the permutation
  $h$, i.e. maps $(\ldots,a_i,\ldots) \in A^n$ to
  $(\ldots,a_{j},\ldots)$ where $j^h = i$.
\end{definition}

As the wreath product is a semidirect product, we have the following
lemma.

\begin{lemma}\label{lem-wreath-property}
  The wreath product $W_n(A)$ contains (isomorphic copies of) $S_n$
  and $A^n$ as subgroups such that $A^n$ is normal and the quotient
  group $W_n(A)/A^n=S_n$.
\end{lemma}

For the rest of the section fix the following: Let $T$ be a tree with
root $\omega$ with $k$ children. Consider the subtrees of $T$ rooted
at each of these $k$ children and partition them such that two
subtrees are in the same partition if and only if they are
isomorphic. Let $t$ be the number of partitions and let $k_i$, for $(1
\leq i \leq t)$, be the number of subtrees in the $i$-th
partition. For each $i$, pick a representative subtree $T_i$ from the
$i$-th partition and let $A_i$ denote the automorphism group of
$T_i$. The following result is well known but a proof is given for
completeness.

\begin{theorem}\label{thmtreeauto}
  The automorphism group of the tree $T$ is (isomorphic to) the direct
  product $\prod_{i=1}^t W_{k_i}(A_i)$.
\end{theorem}
\begin{proof}
  Let $\omega_1,\ldots,\omega_k$ be the children of the root $\omega$
  and let $X_i$ denote the subtree rooted at $\omega_i$. We first
  consider the case when $t=1$, i.e. all the subtrees $X_i$ are
  isomorphic. Any automorphism $g$ of $T$ must permute the children
  $\omega_i$'s among themselves and whenever $\omega_i^g = \omega_j$,
  the entire subtree $X_i$ maps to $X_j$.  As all the subtrees $X_i$
  are isomorphic to $T_1$, the forest $\{X_1,\ldots, X_k\}$ can be
  thought of as the disjoint union of $k$ copies of the tree $T_1$ by
  fixing, for each $i$, an isomorphism $\sigma_i$ from $T_1$ to $X_i$.

  For an automorphism $g$ of $T$, define the permutation $\tilde{g}\in
  S_k$ and the automorphisms $a_i(g)$ of $T_1$ as follows: if
  $\omega_i^g = \omega_j$ then $i^{\tilde{g}} = j$ and $a_i(g) =
  \sigma_i g \sigma_j^{-1}$.  Consider the map $\phi$ from $\Aut{T}$
  to $W_k(A)$ which maps an automorphism $g$ to the group element
  $(\tilde{g},a_1(g),\ldots,a_k(g))$ in $W_k (A)$.  It is easy to
  verify that $\phi$ is the desired isomorphism.

  When the number of partitions $t$ is greater than $1$, any
  automorphism of $T$ fixes the root $\omega$ and permutes the
  subtrees in the $i$-th partition among themselves. Therefore the
  automorphism group of $T$ is same as the automorphism group of the
  collection of forests $F_i$ one for each partition $i$. Each forest
  is a disjoint union of $k_i$ copies of $T_i$ and we can argue as
  before that its automorphism group is (isomorphic to)
  $W_{k_i}(A)$. Therefore $\Aut{T}$ should be the direct product
  $\prod_{i=1}^t W_{k_i}(A_i)$.
\end{proof}

\begin{lemma}\label{lem-break1}
  If the group $G$ can be represented on the tree $T$, then there
  exists $1\leq i \leq t$ such that there is a nontrivial homomorphism
  from $G$ to $W_{k_i}(A_i)$.
\end{lemma}

\begin{proof}
  If there is a nontrivial homomorphism from a group $G$ to the direct
  product of groups $H_1,\ldots,H_t$ then for some $i$, $1 \leq i \leq
  t$, there is a nontrivial homomorphism from $G$ to $H_i$. The lemma
  then follows from Theorem \ref{thmtreeauto}.
\end{proof}

\begin{lemma}\label{lem-break2}
  If there is a nontrivial homomorphism $\rho$ from a group $G$ to
  $W_n(A)$ then there is also a nontrivial homomorphism from $G$
  either to $S_n$ or to $A$.
\end{lemma}
\begin{proof}
  Let $\rho$ be a nontrivial homomorphism $G$ to $W_n(A)$. Since $A^n$
  is a normal subgroup of $W_n(A)$ and the quotient group $W_n(A)/A^n$
  is $S_n$, there is a homomorphism $\rho'$ from $W_n(A)$ to $S_n$
  with kernel $A^n$.  The composition of $\rho$ and $\rho'$ is a
  homomorphism from $G$ to $S_n$.

  If $\rho'\cdot\rho$ is trivial then $\rho'$ maps all elements of
  $\rho(G)$ to identity of $S_n$. Which imply that $\rho(G)$ is a
  subgroup of the kernel of $\rho'$, that is $A^n$. So, $\rho$ is a
  nontrivial homomorphism from $G$ to $A^n$. Hence there must be a
  nontrivial homomorphism from $G$ to $A$.
\end{proof}

\begin{theorem}
  Given a group $G$ and a rooted tree $T$ with $n$ nodes and an oracle
  for deciding whether $G$ has a nontrivial homomorphism to $S_m$ for
  $1 \leq m \leq n$, it can be decided in polynomial time whether $G$
  can be represented on $T$.
\end{theorem}

\begin{proof}
  If the tree has only one vertex then reject. Otherwise let $t$,
  $k_1,\ldots, k_t$ and $A_1,\ldots A_t$ be the quantities as defined
  in Theorem~\ref{thmtreeauto}. Since there is efficient algorithm to
  compute tree isomorphism, $t$ and $k_1,\ldots, k_t$ can be computed
  in polynomial time. If $G$ is representable on $T$ then, by
  Lemma~\ref{lem-break1} and Lemma~\ref{lem-break2}, there is a
  nontrivial homomorphism from $G$ to either $S_{k_i}$ or $A_i$ for
  some $i$. Using the oracle, check whether there is a nontrivial
  homomorphism to any of the symmetric groups. If found then accept,
  otherwise for all $i$, decide whether there is a nontrivial
  homomorphism to $A_i$ by choosing a subtree $T_i$ from the $i^{th}$
  partition and recursively asking whether $G$ is representable on
  $T_i$. Total number of recursive calls is bounded by the number of
  vertices of $T$. Hence the reduction is polynomial time.
\end{proof}

\section{Conclusion}

In this paper we studied the group representability problem, a
computational problem that is closely related to graph
isomorphism. The representability problem could be equivalent to graph
isomorphism, but the results of
Section~\ref{sect-tree-representability} give some, albeit weak,
evidence that this might not be the case. It would be interesting to
know what is the exact complexity of this problem vis a vis the graph
isomorphism problem. We know from the work of
Mathon~\cite{mathon79note} that the graph isomorphism problem is
equivalent to its functional version where, given two graphs $X$ and
$Y$, we have to compute an isomorphism if there exists one. The
functional version of group representability, namely give a group $G$
and a graph $X$ compute a nontrivial representation if it exists, does
not appear to be equivalent to the decision version. Also it would be
interesting to know if the representability problem shares some of
lowness of graph
isomorphism~\cite{schoning87graph,kobler92graph,arvind2002graph}.  Our
hope is that, like the study of group representation in geometry and
mathematics, the study of group representability on graphs help us
better understand the graph isomorphism problem.

\bibliographystyle{plain}
\bibliography{./bibdata}

\end{document}

http://www.usna.edu/Users/math/wdj/repn_thry_appl.htm


% Section: Related Work
\section{Related Work} \label{sec:related}
\para{Gaussian Process Regression}
Rasmussen\cite{rasmussen2006gaussian} and Williams\cite{williams1998prediction} have a wonderful fundamental work on the introduction of Gaussian Process Regression.

\para{Kernel Choice}
Duvenaud et.al introduce a GP model of functions which are additive\cite{duvenaud2011additive}.
Along with Lloyd et.al, they introduce a way to automatic construct some desired kernels to better fit the dataset\cite{duvenaud2013structure,duvenaud2014automatic}.
They also figure out an auto way to produce the Natural-Language description of a data structure\cite{lloyd2014automatic}.
In this paper, we will give a precise introduction on the above work.

\para{Inference Methods}
Some popular works on inference methods include
MCMC\cite{gamerman1997sampling},
Expectation Propagation\cite{minka2001expectation},
Variational Bayes\cite{palmer2006variational,nickisch2009convex},
Leave-One-Out\cite{fukunaga1989leave},
and Laplace Approximation\cite{tierney1986accurate},
etc.
Due to the limited time and space, we won't go very deep into these inference methods.\\ \\


\subsection{L-shaped bracket}
\label{subsection:l_shaped_bracket}
\paragraph{}
In this example, an L-shaped bracket with isotropic material properties is considered.
Fig.~\ref{iso_fig:l_with_fillet_geo_bc} shows the geometry and the boundary conditions of the problem.
The L-shaped bracket is fixed at one end and subjected to downward vertical displacement at the other end.
Plain strain conditions are assumed.
    \begin{figure}[h!]
        \centering
        \scalebox{0.6}{
            \includegraphics{isogeometric_sbfem/images/l_with_fillet_geo_bc.eps}
        }
        \caption{Geometry and boundary conditions}
        \label{iso_fig:l_with_fillet_geo_bc}
    \end{figure}
%
The dimension of the example is: $L=\SI{14}{\meter}$, $W=\SI{4}{\meter}$ and $R=\SI{1}{\meter}$.
While the material properties are: Young's modulus $E=\SI{1e3}{\mega\pascal}$ and poisson's ratio $\nu=0.3$.
This problem was studied in \citep{LIPTON2010357} by employing the conventional IGA.
In their study, the fillet was modeled as a separate path using biquadratic NURBS with nine control points.

\paragraph{}
In the present study, the control mesh is directly employed for the stress analysis.
However, as the domain does not meet the star convexity, we divide the domain into three subdomains (see Fig.~\ref{iso_fig:l_with_fillet_mesh}).
We employ NURBS to represent the fillet, whilst for the straight lines, we employ Lagrange basis functions.
The results from the present approach are compared with conventional finite element analysis using the commercial
    software ANSYS$^\circledR$.
    \begin{figure}[h!]
        \centering
        \scalebox{0.6}{
            \includegraphics{isogeometric_sbfem/images/l_with_fillet_mesh.png}
        }
        \caption{Control net where `filled' circles represents control points}
        \label{iso_fig:l_with_fillet_mesh}
    \end{figure}
%
\paragraph{}
A total of $2000$ $8$-node quadrilateral elements were used for the finite element analysis.
Fig.~\ref{iso_fig:l_stress_contour} shows the von Mises equivalent stress for the L-shaped bracket with and without the fillet.
As expected, the no fillet case shows higher stress when compared to the L-shaped bracket with the fillet.
From Fig.~\ref{iso_fig:l_stress_contour}, it can be observed that the results from the present approach qualitatively match with the FE solution.
It should be noted that, the proposed method is computationally less intensive than the conventional IGA as it requires
    only the boundary information.
    \begin{figure}[h!]
        \begin{subfigure}[b]{0.5\linewidth}
            \centering
            \scalebox{0.5}{
                \includegraphics{isogeometric_sbfem/images/l_stress_contour_fem.png}
            }
            \caption{FEM}
        \end{subfigure}
        \begin{subfigure}[b]{0.5\linewidth}
            \centering
            \scalebox{0.5}{
                \includegraphics{isogeometric_sbfem/images/l_stress_contour_sbfem.png}
            }
            \caption{Isogeometric SBFEM}
        \end{subfigure}

        \begin{subfigure}[b]{0.5\linewidth}
            \centering
            \scalebox{0.5}{
                \includegraphics{isogeometric_sbfem/images/l_with_fillet_stress_contour_fem.png}
            }
            \caption{FEM}
        \end{subfigure}
        \begin{subfigure}[b]{0.5\linewidth}
            \centering
            \scalebox{0.5}{
                \includegraphics{isogeometric_sbfem/images/l_with_fillet_stress_contour_sbfem.png}
            }
            \caption{Isogeometric SBFEM}
        \end{subfigure}
        \caption[Von Mises equivalent stress contours for L-shaped bracket without and with fillet]{Von Mises equivalent stress contours for L-shaped bracket without and with fillet. The stress values are in Mpa}
        \label{iso_fig:l_stress_contour}
    \end{figure}
%

%=================================================================================================================================%
\paragraph{}
Next, we extend the present formulation to study the transient response of an L-shaped bracket.
The dimensions and the boundary conditions are shown in Fig.~\ref{iso_fig:l_dynamic_geo_bc}.
    \begin{figure}
        \begin{subfigure}[b]{1\linewidth}
            \centering
            \scalebox{0.8}{
                \includegraphics{isogeometric_sbfem/images/l_dynamic_geo_bc.eps}
            }
            \caption{without fillet}
        \end{subfigure}
        \begin{subfigure}[b]{1\linewidth}
            \centering
            \scalebox{0.8}{
                \includegraphics{isogeometric_sbfem/images/l_with_fillet_dynamic_geo_bc.eps}
            }
            \caption{without fillet}
        \end{subfigure}
        \caption{L-shaped bracket: geometry and boundary conditions for transient analysis}
        \label{iso_fig:l_dynamic_geo_bc}
    \end{figure}
%
\paragraph{}
In the example, $b=\SI{1}{\meter}$ and $r=\SI{0.2}{\meter}$.
A state of plane stress is considered and the material properties are:
    Young’s modulus $E = \SI{1}{\newton \per \square \meter}$ , poisson’s ratio, $\nu = 1/3$ and mass density, $\rho = \SI{1}{\kilo \gram \per \cubic \meter}$.
    The shear wave velocity is $c_s=\SI[parse-numbers = false]{\sqrt{3/8}}{\meter \per \second}$
    and the dilatational wave velocity $c_p=\SI[parse-numbers = false]{\sqrt{9/8}}{\meter \per \second}$
The order of the continued fraction used in Eq.~\ref{lr_eq:sbfem_dynamic_s_full} is chosen as $M_{cf} = 6$.
A uniform pressure $p(t)$ is applied at the side BC of the bracket.
The pressure varies as a triangular impulse in the time domain.
It reaches a peak value $p$ at time $t= 0.5b/c_p$ , reduces to $0$ at $t = b/c_p$ and stays at $0$ afterwards.
The time integration is carried out by using Newmark's method with $\gamma = 1/2$ and $\beta = 1/4$.
The time step is chosen as $\delta t = 0.025b/c_p$.

\paragraph{}
The calculation is performed for 3000 time steps.
For the Isogeometric-SBFEM, the arc is represented with quadratic NURBS functions and the straight lines are discretized with
    Lagrange basis functions.
As the problem domain does not satisfy the star convexity, the domain is sub-divided into three subdomains as done in the static example.
The scaling center for each of the subdomain is placed at the center of the subdomain.
To demonstrate the efficacy of the present formulation, the results are compared with those obtained using the conventional
    finite element method.
A FE mesh leading to a similar accuracy is identified from a convergence study.
The FE analysis is performed with the commercial software ANSYS$^\circledR$ (a total of 2000 8-node quadrilateral elements
    were employed for this study).

\paragraph{}
The vertical displacement responses at point A are plotted in Fig.~\ref{iso_fig:l_uy_dynamic_at_A} as a function of the dimensionless
    time $T = c_pt/b$.
It can be seen that the results from the present formulation agree well with the finite element solution.
    \begin{figure}
        \centering
        \scalebox{0.5}{
            \includegraphics{isogeometric_sbfem/images/l_uy_at_A.png}
        }
    \caption{Vertical displacement of L-shaped bracket at Point A: comparison with conventional FE solution}
    \label{iso_fig:l_uy_dynamic_at_A}
    \end{figure}
%


\subsubsection*{Ternary Operations\hspace*{\fill}\hyperlink{ElementwiseOperations}{(up)}\hypertarget{ternaryOperations}{}}\addcontentsline{toc}{subsubsection}{Ternary Operations}
Ternary operations are those involving three inputs such as $ y = a \cdot x + b$ or $y = (a + b) \cdot x$. They are defined in the element-wise chapter of the C VSIPL specification.\\
We note that the VSIPL specification only defines ternary operations for \ttbf{view}s of shape vector and precision float. Both complex and real are covered although no mixed depths are defined. Some ternary operations involve scalar constants.
\begin{table}[H]
\caption{Ternary Operations}
\label{tab:ternaryOperations}
\begin{center}
\begin{tabular}{|l|l|}\hline
\hlnkFunc{am} & Add and multiply \\
\hlnkFunc{ma} & Multiply and add \\
\hlnkFunc{msb} & Multiply and subtract\\
\hlnkFunc{sbm} & Substract and multiply\\
\hline\end{tabular}
\end{center}
%\label{default}
\end{table}%


\chapter{Ambiguity Resolution}
\label{ch:Ambiguity Resolution}
An advantage of the ambiguity fixed solutions is the significantly reduced number of parameters which have to be solved for.
A reduction of the normal equation to be inverted is important because usually a duplication of its size leads to over four times longer computing time for the inversion.
If many parameters are estimated (orbits, Earth orientation parameters etc.) ambiguity resolution improves also the results of much longer sessions than the traditional daily solution.
Due to the FDMA technology the ambiguity resolution for GLONASS is not a straight forward task, and we have not attempted to implement this into the pea yet.
%
There are many methods that can be used to resolve ambiguities, but they mainly consist of two steps:
%
\begin{enumerate}
    \item The ambiguities are estimates as real numbers (with the other parameters).
    \item Integer values of the ambiguities are resolved using the results of step 1 (the real-value ambiguities and the VCV matrix) employing a number of statistical tests to ensure a reliable estimate.
\end{enumerate}
%
\textit{Determining a reference or a pivot} is normally done by selecting a station with the most number of observations, however this is not possible to no apriori for a systems that is designed to run in real-time.
%
In the pea we have implemented a number of different ambiguity resolution strategies:
\begin{itemize}
    \item rounding and weighted rounding
    \item bootstrapping
    \item lambda decorelation
    \item BIE
\end{itemize}
%
\section{rounding algorithm}
The simplest strategy to apply is to round the real-values estimates to the nearest integers, without using any variance co-variance information.
%
\section{bootstrapping}
%
The bootstrapping algorithm takes the first ambiguity and rounds its value to the nearest integer. Having obtained the integer value of this first ambiguity, the real-valued estimates of all remaining ambiguities are then corrected by virtue of their correlation with the first ambiguity.
Then the second, but now corrected, real-valued ambiguity estimate is rounded to its nearest integer, and the process is then repeated again with both ambiguities held fixed, and the process is continued until all ambiguities are accommodated.
Thus the bootstrapped estimator reduces to ’integer rounding’ in case correlations are absent.
%
\section{lambda}
\section{BIE}
The previously mentioned algorithms are known as @hard decision algorithms.

\subsection{Melbourne-Wubbena linear combination}
The Melbourne-Wubbena linear combination (Melbourne 1985),(Wubbena 1985) is a linear combination of the L1 and L2 carrier phase plus the P1 and P2 pseudorange. The geometry, troposphere and ionosphere are eliminated by it. The Melbourne-Wubbena linear combination can be represented as:
%
\begin{equation}
E(L_{r,IF}^S) - \frac{cf_2z_{r,w}^s}{f_1^2 - f_2^2} = \rho_r^s + c(dt_{r,IF} - dt_{IF}^s) + \tau_r^s + \lambda_n z_{r,1}^s + (\lambda_{IF}\delta_{r,IF}
\end{equation}
%
Since ,,\% comprises of both code and phase measurements, it is reasonable to exclude the lower
elevation measurements to avoid the multipath impacts from the code observation. Normally, with
30 degree elevation cut-off, an averaging of 5 minutes of (4) is good enough to fixing the wide-lane
ambiguities [RD 04]. The rests are the wide-lane phase bias, which can be broadcasted to the user for
user side wide-lane ambiguity resolution. Either choosing a pivot receiver bias or a single-differencing
between two satellites can avoid the linear dependency.
%
%
doesn't need lambda not as correlated
%
\section{Narrowlane and phase clock estimation}
%
highly correlated need lambda
% \[E(L^S) - \]
%
%
With the fixing of the wide-lane ambiguity, equation (1) and (2) can be further deducted as:
%
The code bias and phase bias in equations \eqref{obsEq} and (6) can be lumped into the corresponding receiver
and satellite clock errors. Then equations (5) and (6) become:
%
with:
%
By such an reformulation, there are two types of satellite clock: 1) IGS type clock, but estimated only
from code measurements; 2) phase clock, estimated using phase measurements and can be used to
support PPP ambiguity resolution on the user side. The drawback of this approach is that there is no
precise IGS compatible clock after the processing and it has to be derived from the existing PEA
processing
%
\section{Narrowlane and phase bias estimation}
%
In this approach, equation (7) holds the same for the code measurements. However, in equation (8),
the phase biases are not lumped into the clocks, but the ambiguities. More specifically, equation (8)
can be written as:
%
In equation (9), the clocks are the same as the clocks provided in equation (7), which means the
precise IGS satellite clock can be estimated.
The narrow-lane integer ambiguities, as shown in equation (9), are linearly dependent on the phase
biases, which means they cannot be estimated simultaneously. However, similar as the wide-lane
ambiguity resolution, the narrow-lane integer ambiguities can be fixed by rounding the float solution
to the nearest integer, and the remaining will be the phase bias, which can be broadcasted to the
user for user side PPP ambiguity resolution.
%
\textit{Bootstrapping} is designed to do some stuff.
%
\textit{Rounding}
%
\textit{Lambda}
%
Decorrelation algorithm
%
%2 nearest
%
\section{References on Ambiguity Resolution}
%
\begin{itemize}
    \item A modified phase clock/bias model to improve PPP ambiguity resolution at Wuhan University Journal of Geodesy - Geng et al. (2019)
    \item On the interoperability of IGS products for precise point positioning with ambiguity resolution Journal of Geodesy - Simon et al. (2020)
    \item Resolution of GPS carrier-phase ambiguities in precise point positioning (PPP) with daily observations Journal of Geodesy - Ge et al. (2008)
    \item Real time zero-difference ambiguities fixing and absolute RTK ION NTM - Laurichesse et al. (2008)
    \item Undifferenced GPS ambiguity resolution using the decoupled clock model and ambiguity datum fixing Navigation – Collins et al. (2010)
    \item Improving the estimation of fractional-cycle biases for ambiguity resolution in precise point positioning Journal of Geodesy – Geng (2012).
    \item Modeling and quality control for reliable precise point positioning integer ambiguity resolution with GNSS modernization
GPS Solutions – Li et al. (2014).
\end{itemize}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% LaTeX Example: Project Report
%
% Source: http://www.howtotex.com
%
% Feel free to distribute this example, but please keep the referral
% to howtotex.com
% Date: March 2011
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% How to use writeLaTeX:
%
% You edit the source code here on the left, and the preview on the
% right shows you the result within a few seconds.
%
% Bookmark this page and share the URL with your co-authors. They can
% edit at the same time!
%
% You can upload figures, bibliographies, custom classes and
% styles using the files menu.
%
% If you're new to LaTeX, the wikibook is a great place to start:
% http://en.wikibooks.org/wiki/LaTeX
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Edit the title below to update the display in My Documents
%\title{Project Report}
%
%%% Preamble
\documentclass[paper=a4, fontsize=11pt]{scrartcl}
\usepackage[T1]{fontenc}
\usepackage{fourier}

\usepackage[english]{babel}															% English language/hyphenation
\usepackage[protrusion=true,expansion=true]{microtype}
\usepackage{amsmath,amsfonts,amsthm} % Math packages
\usepackage[pdftex]{graphicx}
\usepackage{url}
\usepackage{caption}
\usepackage[top=1in, bottom=1in, left=1in, right=1in]{geometry}
\usepackage{subcaption}  % For placing two subfigures side by side

%%% Custom sectioning
\usepackage{sectsty}
\usepackage{multirow}
\allsectionsfont{\centering \normalfont\scshape}

%%% Inserting landscape pages
\usepackage{pdflscape}

%%% Custom headers/footers (fancyhdr package)
\usepackage{fancyhdr}
\pagestyle{fancyplain}
\fancyhead{}											% No page header
\fancyfoot[L]{}											% Empty
\fancyfoot[C]{}											% Empty
\fancyfoot[R]{\thepage}									% Pagenumbering
\renewcommand{\headrulewidth}{0pt}			% Remove header underlines
\renewcommand{\footrulewidth}{0pt}				% Remove footer underlines
\setlength{\headheight}{13.6pt}
\setlength{\fboxrule}{1mm}
\setlength{\fboxsep}{5mm}

%%% Equation and float numbering
\numberwithin{equation}{section}		% Equationnumbering: section.eq#
\numberwithin{figure}{section}			% Figurenumbering: section.fig#
\numberwithin{table}{section}				% Tablenumbering: section.tab#

%%% Maketitle metadata
\newcommand{\horrule}[1]{\rule{\linewidth}{#1}} 	% Horizontal rule

\title{
		%\vspace{-1in}
		\usefont{OT1}{bch}{b}{n}
		\horrule{0.5pt} \\[0.2cm]
		\LARGE General expressions of bsplines of degree 0,1,2 and 3 in 1D\\
        -\\
        \normalsize Another tool for ToFu
		\horrule{2pt} \\[0.3cm]
}
\author{D. VEZINET}
\date{\today}

% Graphics path
\graphicspath{ {./} }

%%% Begin document
\begin{document}
\maketitle

\tableofcontents

\newpage
\section{General expression of the bsplines}

\begin{figure}[hbtp]
    \centering
    \includegraphics[scale=0.50]{BSplines_GeneralExpression_Deriv0.pdf}
    \caption{\small Bsplines of degrees 0, 1, 2 and 3}
    \label{Fig:Grid}
\end{figure}

A b-spline $b_{d,0}$ of degree $d$ living from $x_0$ is:$ b_{d,0} = \frac{x-x_0}{x_{0+d}-x_0}b_{d-1,0} + \frac{x_{0+d+1}-x}{x_{0+d+1}-x_{0+1}}b_{d-1,1} $\\
Hence:

$$
b_{0,0} =
\left\{
\begin{array}{lll}
1 & \text{ ,  if  } & x \in [x_0,x_1[\\
0 & \text{ ,  else}
\end{array}
\right.
$$

$$
b_{1,0} =
\left\{
\begin{array}{lll}
\frac{x-x_0}{x_1-x_0} & \text{ ,  if  } & x \in [x_0,x_1[\\
\frac{x_2-x}{x_2-x_1} & \text{ ,  if  } & x \in [x_1,x_2[
\end{array}
\right.
$$

$$
b_{2,0} =
\left\{
\begin{array}{lll}
\frac{(x-x_0)^2}{(x_2-x_0)(x_1-x_0)} & \text{ ,  if  } & x \in [x_0,x_1[\\
\frac{(x-x_0)(x_2-x)}{(x_2-x_0)(x_2-x_1)} + \frac{(x-x_1)(x_3-x)}{(x_2-x_1)(x_3-x_1)} & \text{ ,  if  } & x \in [x_1,x_2[\\
\frac{(x_3-x)^2}{(x_3-x_2)(x_3-x_1)} & \text{ ,  if  } & x \in [x_2,x_3[
\end{array}
\right.
$$

$$
b_{3,0} =
\left\{
\begin{array}{lll}
\frac{(x-x_0)^3}{(x_3-x_0)(x_2-x_0)(x_1-x_0)} & \text{ ,  if  } & x \in [x_0,x_1[\\
\frac{x-x_0}{x_3-x_0}\left(\frac{(x-x_0)(x_2-x)}{(x_2-x_0)(x_2-x_1)} + \frac{(x-x_1)(x_3-x)}{(x_2-x_1)(x_3-x_1)}\right) + \frac{x_4-x}{x_4-x_1}\left(\frac{(x-x_1)^2}{(x_3-x_1)(x_2-x_1)}\right) & \text{ ,  if  } & x \in [x_1,x_2[\\
\frac{x-x_0}{x_3-x_0}\left(\frac{(x_3-x)^2}{(x_3-x_2)(x_3-x_1)}\right) + \frac{x_4-x}{x_4-x_1}\left(\frac{(x-x_1)(x_3-x)}{(x_3-x_1)(x_3-x_2)} + \frac{(x-x_2)(x_4-x)}{(x_3-x_2)(x_4-x_2)}\right)& \text{ ,  if  } & x \in [x_2,x_3[\\
\frac{(x_4-x)^3}{(x_4-x_3)(x_4-x_2)(x_4-x_1)} & \text{ ,  if  } & x \in [x_3,x_4[
\end{array}
\right.
$$

Or (see \ref{Ap:DistribueDeg3} for details):

$$
b_{2,0} =
\left\{
\begin{array}{lll}
\frac{x^2-2xx_0+x_0^2}{(x_2-x_0)(x_1-x_0)} & \text{ ,  if  } & x \in [x_0,x_1[\\
\frac{-x^2(x_3+x_2-x_1-x_0) + 2x(x_3x_2-x_1x_0) - (x_3x_2x_0 - x_2x_1x_0 + x_3x_2x_1 - x_3x_1x_0)}{ (x_2-x_1)(x_2-x_0)(x_3-x_1)} & \text{ ,  if  } & x \in [x_1,x_2[\\
\frac{x^2-2xx_3+x_3^2}{(x_3-x_2)(x_3-x_1)} & \text{ ,  if  } & x \in [x_2,x_3[
\end{array}
\right.
$$

$$
b_{3,0} =
\left\{
\begin{array}{lll}
\frac{x^3 - 3x^2x_0 + 3xx_0^2 - x_0^3}{(x_3-x_0)(x_2-x_0)(x_1-x_0)} & \text{ ,  if  } & x \in [x_0,x_1[\\
\frac{x^3A + x^2B + xC + D}{(x_4-x_1)(x_3-x_1)(x_3-x_0)(x_2-x_1)(x_2-x_0)} & \text{ ,  if  } & x \in [x_1,x_2[\\
\frac{x^3A^/ + x^2B^/ + xC^/ + D^/}{(x_4-x_2)(x_4-x_1)(x_3-x_2)(x_3-x_1)(x_3-x_0)} & \text{ ,  if  } & x \in [x_2,x_3[\\
\frac{-x^3 + 3x^2x_4 - 3xx_4^2 + x_4^3}{(x_4-x_3)(x_4-x_2)(x_4-x_1)} & \text{ ,  if  } & x \in [x_3,x_4[
\end{array}
\right.
$$

\newpage
\section{Derivatives}

By noting $\partial_n b_{d,0}$ the $n$-th derivative of b-spline $b_{d,0}$, where $n\leq d$:

$$
\partial_1 b_{1,0} =
\left\{
\begin{array}{lll}
\frac{1}{x_1-x_0} & \text{ ,  if  } & x \in [x_0,x_1[\\
\frac{-1}{x_2-x_1} & \text{ ,  if  } & x \in [x_1,x_2[
\end{array}
\right.
$$

$$
\partial_1 b_{2,0} =
\left\{
\begin{array}{lll}
\frac{2(x-x_0)}{(x_2-x_0)(x_1-x_0)} & \text{ ,  if  } & x \in [x_0,x_1[\\
\frac{-2x(x_3+x_2-x_1-x_0) + 2(x_3x_2-x_1x_0)}{ (x_2-x_1)(x_2-x_0)(x_3-x_1)} & \text{ ,  if  } & x \in [x_1,x_2[\\
\frac{-2(x_3-x)}{(x_3-x_2)(x_3-x_1)} & \text{ ,  if  } & x \in [x_2,x_3[
\end{array}
\right.
$$

$$
\partial_2 b_{2,0} =
\left\{
\begin{array}{lll}
\frac{2}{(x_2-x_0)(x_1-x_0)} & \text{ ,  if  } & x \in [x_0,x_1[\\
\frac{-2(x_3+x_2-x_1-x_0)}{ (x_2-x_1)(x_2-x_0)(x_3-x_1)} & \text{ ,  if  } & x \in [x_1,x_2[\\
\frac{2}{(x_3-x_2)(x_3-x_1)} & \text{ ,  if  } & x \in [x_2,x_3[
\end{array}
\right.
$$

$$
\partial_1 b_{3,0} =
\left\{
\begin{array}{lll}
\frac{3(x-x_0)^2}{(x_3-x_0)(x_2-x_0)(x_1-x_0)} & \text{ ,  if  } & x \in [x_0,x_1[\\
\frac{3x^2A + 2xB + C}{(x_4-x_1)(x_3-x_1)(x_3-x_0)(x_2-x_1)(x_2-x_0)} & \text{ ,  if  } & x \in [x_1,x_2[\\
\frac{3x^2A^/ + 2xB^/ + C^/}{(x_4-x_2)(x_4-x_1)(x_3-x_2)(x_3-x_1)(x_3-x_0)} & \text{ ,  if  } & x \in [x_2,x_3[\\
\frac{-3(x_4-x)^2}{(x_4-x_3)(x_4-x_2)(x_4-x_1)} & \text{ ,  if  } & x \in [x_3,x_4[
\end{array}
\right.
$$

$$
\partial_2 b_{3,0} =
\left\{
\begin{array}{lll}
\frac{6(x-x_0)}{(x_3-x_0)(x_2-x_0)(x_1-x_0)} & \text{ ,  if  } & x \in [x_0,x_1[\\
\frac{6xA + 2B}{(x_4-x_1)(x_3-x_1)(x_3-x_0)(x_2-x_1)(x_2-x_0)} & \text{ ,  if  } & x \in [x_1,x_2[\\
\frac{6xA^/ + 2B^/}{(x_4-x_2)(x_4-x_1)(x_3-x_2)(x_3-x_1)(x_3-x_0)} & \text{ ,  if  } & x \in [x_2,x_3[\\
\frac{6(x_4-x)}{(x_4-x_3)(x_4-x_2)(x_4-x_1)} & \text{ ,  if  } & x \in [x_3,x_4[
\end{array}
\right.
$$

$$
\partial_3 b_{3,0} =
\left\{
\begin{array}{lll}
\frac{6}{(x_3-x_0)(x_2-x_0)(x_1-x_0)} & \text{ ,  if  } & x \in [x_0,x_1[\\
\frac{6A}{(x_4-x_1)(x_3-x_1)(x_3-x_0)(x_2-x_1)(x_2-x_0)} & \text{ ,  if  } & x \in [x_1,x_2[\\
\frac{6A^/}{(x_4-x_2)(x_4-x_1)(x_3-x_2)(x_3-x_1)(x_3-x_0)} & \text{ ,  if  } & x \in [x_2,x_3[\\
\frac{-6}{(x_4-x_3)(x_4-x_2)(x_4-x_1)} & \text{ ,  if  } & x \in [x_3,x_4[
\end{array}
\right.
$$

\newpage
\begin{landscape}

\begin{figure}[hbtp]
    \centering
    \includegraphics[scale=0.75]{tests01_bsplines_test02_BSpline_LFunc.pdf}
    \caption{\small Bsplines of degrees 0, 1, 2 and 3 and their derivatives D0, D1, D2 and D3}
    \label{Fig:Deriv}
\end{figure}

\newpage
\appendix

\section{Distributing the degree 3 polynoms}
\label{Ap:DistribueDeg3}

$$
\begin{array}{ll}
& \frac{x-x_0}{x_3-x_0}\left(\frac{(x-x_0)(x_2-x)}{(x_2-x_0)(x_2-x_1)} + \frac{(x-x_1)(x_3-x)}{(x_2-x_1)(x_3-x_1)}\right) + \frac{x_4-x}{x_4-x_1}\left(\frac{(x-x_1)^2}{(x_3-x_1)(x_2-x_1)}\right)\\
= & \frac{ (x-x_0)^2(x_2-x)(x_3-x_1)(x_4-x_1) + (x-x_0)(x-x_1)(x_3-x)(x_2-x_0)(x_4-x_1) + (x_4-x)(x-x_1)^2(x_3-x_0)(x_2-x_0) }{(x_4-x_1)(x_3-x_1)(x_3-x_0)(x_2-x_1)(x_2-x_0)}\\
= & \frac{ (x^2-2xx_0+x_0^2)(x_2-x)(x_3-x_1)(x_4-x_1) + (x^2-x(x_0+x_1)+x_0x_1)(x_3-x)(x_2-x_0)(x_4-x_1) + (x^2-2xx_1+x_1^2)(x_4-x)(x_3-x_0)(x_2-x_0) }{(x_4-x_1)(x_3-x_1)(x_3-x_0)(x_2-x_1)(x_2-x_0)}\\

= & \frac{ (x^2x_2-2xx_2x_0+x_2x_0^2 - x^3+2x^2x_0-xx_0^2)(x_3-x_1)(x_4-x_1) + (x^2x_3-xx_3(x_0+x_1)+x_0x_1x_3 - x^3+x^2(x_0+x_1)-xx_0x_1)(x_2-x_0)(x_4-x_1)
+ (x^2x_4-2xx_4x_1+x_4x_1^2 - x^3+2x^2x_1-xx_1^2)(x_3-x_0)(x_2-x_0) }{(x_4-x_1)(x_3-x_1)(x_3-x_0)(x_2-x_1)(x_2-x_0)}\\

= & \frac{1}{(x_4-x_1)(x_3-x_1)(x_3-x_0)(x_2-x_1)(x_2-x_0)} \left[ \begin{array}{ll}
-x^3((x_3-x_1)(x_4-x_1) + (x_2-x_0)(x_4-x_1) + (x_3-x_0)(x_2-x_0))\\
+ x^2( (x_2+2x_0)(x_3-x_1)(x_4-x_1) + (x_3+x_0+x_1)(x_2-x_0)(x_4-x_1) + (x_4+2x_1)(x_3-x_0)(x_2-x_0) )\\
+ x( -x_0(2x_2+x_0)(x_3-x_1)(x_4-x_1) - (x_3(x_0+x_1)+x_0x_1)(x_2-x_0)(x_4-x_1) - x_1(2x_4+x_1)(x_3-x_0)(x_2-x_0) )\\
+ x_2x_0^2(x_3-x_1)(x_4-x_1) + x_0x_1x_3(x_2-x_0)(x_4-x_1) + x_4x_1^2(x_3-x_0)(x_2-x_0)
\end{array}\right]\\

= & \frac{ Ax^3 + Bx^2 + Cx + D }{(x_4-x_1)(x_3-x_1)(x_3-x_0)(x_2-x_1)(x_2-x_0)}

\end{array}
$$

where $\left\{\begin{array}{ll}
A & = -((x_3-x_1)(x_4-x_1) + (x_2-x_0)(x_4-x_1) + (x_3-x_0)(x_2-x_0))\\
B & = (x_2+2x_0)(x_3-x_1)(x_4-x_1) + (x_3+x_0+x_1)(x_2-x_0)(x_4-x_1) + (x_4+2x_1)(x_3-x_0)(x_2-x_0)\\
C & = -(x_0(2x_2+x_0)(x_3-x_1)(x_4-x_1) + (x_3(x_0+x_1)+x_0x_1)(x_2-x_0)(x_4-x_1) + x_1(2x_4+x_1)(x_3-x_0)(x_2-x_0))\\
D & = x_2x_0^2(x_3-x_1)(x_4-x_1) + x_0x_1x_3(x_2-x_0)(x_4-x_1) + x_4x_1^2(x_3-x_0)(x_2-x_0)
\end{array}\right.$\\

Similarly
$$
\frac{x-x_0}{x_3-x_0}\left(\frac{(x_3-x)^2}{(x_3-x_2)(x_3-x_1)}\right) + \frac{x_4-x}{x_4-x_1}\left(\frac{(x-x_1)(x_3-x)}{(x_3-x_1)(x_3-x_2)} + \frac{(x-x_2)(x_4-x)}{(x_3-x_2)(x_4-x_2)}\right)
= \frac{x^3A^/ + x^2B^/ + xC^/ + D^/}{(x_4-x_2)(x_4-x_1)(x_3-x_2)(x_3-x_1)(x_3-x_0)}
$$

where we simply substitute $(x_0,x_1,x_2,x_3,x_4)$ in $A,B,C,D$ by $(x_4,x_3,x_2,x_1,x_0)$ and notice that the denominator is the opposite of the substituted version:
$$
\left\{\begin{array}{ll}
A^/ & = (x_1-x_3)(x_0-x_3) + (x_2-x_4)(x_0-x_3) + (x_1-x_4)(x_2-x_4)\\
B^/ & = -((x_2+2x_4)(x_1-x_3)(x_0-x_3) + (x_1+x_4+x_3)(x_2-x_4)(x_0-x_3) + (x_0+2x_3)(x_1-x_4)(x_2-x_4))\\
C^/ & = x_4(2x_2+x_4)(x_1-x_3)(x_0-x_3) + (x_1(x_4+x_3)+x_4x_3)(x_2-x_4)(x_0-x_3) + x_3(2x_0+x_3)(x_1-x_4)(x_2-x_4)\\
D^/ & = -(x_2x_4^2(x_1-x_3)(x_0-x_3) + x_4x_3x_1(x_2-x_4)(x_0-x_3) + x_0x_3^2(x_1-x_4)(x_2-x_4))
\end{array}\right.
$$

\end{landscape}

%%% End document
\end{document}


\chapter{Number Theory}

\cpbookimport{CRT.h}
\cpbookimport{PollardsRho.h}
\cpbookimport{RabinMiller.h}
\cpbookimport{Sieve.h}


\chapter{Constructors}

A constructor is a function that helps make a new object.

\index{constructor}

\section{\texttt{new} Constructor}

\index{new}

You will inevitably encounter constructors that require the use of the \texttt{new} keyword. The convention is that the constructor will start with a capitol letter if \texttt{new} is required. As an example of how to use \texttt{new}, an empty object would be created as follows.

\codejs{\source{js/newKeyword.js}}

\textit{Using} that type of constructor is fairly strait-forward. You just have to remember to put a \texttt{new} in front of it. However, \textit{writing} constructors that use \texttt{new} is outside the scope of this text. You will not need \texttt{new} to use the functional constructors we will write, and that is why I have named these constructors beginning with lower-case \texttt{make}.

\section{Inside a Functional Constructor}

A functional constructor could be as simple as returning a new object defined by an object literal.

\codejs{\source{js/makePi.js}}

To use it we simply call the function just like any other function. But it returns an object that has its own properties.

\codejs{\source{js/makePiEx.js}}

The constructor can add anything to the new object to give the object the desired functionality. I will use the convention of naming the object that will be returned from the constructor as \texttt{out} to indicate that anything added to that object will be exposed in the constructed object. Any other local variables will not be exposed, but will still be available to any methods which used them because it forms what is called a closure.

\index{closure}

\codejs{\source{js/CircleA.js}}

When calling the constructor we pass in a number for what we want the radius to be, and it returns the circle object with a couple functions attached to it.

\codejs{\source{js/CircleAEx.js}}

\section{The \texttt{specs} Object}

Another way of defining the argument to a constructor is to pass in a single object where the properties of that object refer to the specifications of the object the constructor is meant to create. This argument can be named with any valid variable name as long as it is used consistently. I have chosen to name it \texttt{specs}.

\codejs{\source{js/Circle.js}}

The \texttt{specs} object can be made using an object literal, and hopefully you can see immediately from reading the code what the inputs are and what they mean.

\codejs{\source{js/constructors.js}}

I have grown to like this method of passing parameters into a constructor for a couple different reasons. For one, it's easy to read what the inputs mean when the constructors appear in the code. It also makes it easy to change the meaning of the inputs without breaking code that's already been written.\\

As a simple example, suppose we decide to define a circle using the diameter instead of the radius, but there is already code written that defines it using the radius. We don't want to have to go back and re-write that code. If we used a \texttt{specs} object, we can just check to see which one is being used.

\codejs{\source{js/Circle2.js}}

Either radius or diameter can be used now with the same constructor.

\codejs{\source{js/constructorsB.js}}

The specs object is not free of issues though. For one, it may not be clear what needs to go into it when looking at the constructor itself. Incidentally it may not be clear what is in the returned object, either. One could look through the code and figure it out, but even in this simple example it may not be clear if the radius is required, or diameter, or both. This is where documentation is important. Here I just include a comment about what properties the input and output objects should have.

\codejs{\source{js/Circle3.js}}

Another possible issue is that any variable passed into a function retains a reference to that same object. If a variable is used to pass in the object, instead of an object literal, unpredictable things could happen if that variable is used to do other things.

\codejs{\source{js/constructorsBerrors.js}}

Can you see what happened? Since the \texttt{specs} object is used by the radius function, it will return the \textit{current} value of that property when that function is called, which is after \texttt{specs} got changed, and not the value it had when the constructor was called originally. If we want to prevent this kind of mistake from being possible, we need to store those values in local variables which will retain their value no matter what happens to the \texttt{specs} object later on.

\codejs{\source{js/Circle4.js}}

Now that piece of code will work as intended.

\section{Extending Objects}

It is convenient to re-used code to make an object that is related to an object that can already be made. This can be done by creating an object with one constructor, and simply adding or modifying its properties in a different constructor. Say we already have some code that constructs a Person object.

\codejs{\source{js/Person.js}}

And we've been creating Person's like this.

\codejs{\source{js/constructors2.js}}

We can now write another constructor that makes use of the Person object that can already be made by simply calling that constructor, then changing the object. In this example, the \texttt{getSignature} function is redefined to include a title. Remember that functions are themselves just objects, so we can save the original function in a local variable, and then re-use it to make writing the new function a little easier.

\codejs{\source{js/Professional.js}}

A specs object can be passed in that will work with both constructors which makes life nice, and the code more consistent.

\codejs{\source{js/constructors3.js}}

Perhaps instead of adding new functionality to an object, we want a constructor that creates a more restricted type of object. All we have to do is create a custom \texttt{specs} object for the other constructor.

\codejs{\source{js/Doe.js}}

Only the first name is needed because the constructor will add the last name when it calls the Person constructor.

\codejs{\source{js/constructors4.js}}

\section{Copy Constructor}

Suppose we have an object already defined, but we want to make another copy of it without having to figure out what the specs object would have to be. We could add a case to handle that within the constructor itself.

\section{Getters and Setters}

\section{}

\section{Sharing Hidden Information}

Hiding information is accomplished by storing values in the local variables of the constructor. These variables are not directly accessible outside of the function, unless a method is added to the \texttt{out} object to do something we want. However, there could be a time that we would like to extend an object and have access to some information defined in another constructor, but still not expose it in the resulting object.\\

Doing this requires a slightly different structure. Instead of having a single layer functional constructor, we need two layers. The first layer creates the object and returns the exposed object, but also an object that contains information that is meant to be hidden. I will name this function starting with the word \texttt{extend}.\\

The second layer hides the information that isn't supposed to be visible and looks like a normal constructor from the outside world. Even though these have to be two separate functions, we could still group them together into a single object, and have the properties of that object be the two functions. Here is an example of a Linear Congruential Generation (pseudo-random numbers).

\codejs{\source{js/BadRandom.js}}

We can use the make function property to make one of these with a seed, and see what numbers come out.

\codejs{\source{js/BadRandomEx.js}}

Testing it out we see that this is not a very good generator, but maybe we have an idea how to change some hidden variables to make it better. We can use the extend method to make a new generator but still re-use the old object.

\codejs{\source{js/BetterRandom.js}}

Test it out to see how long it takes to start repeating the same sequence of numbers.\\

This example may seem silly because we could have just changed the original code. The key is that anything added to hidden can be accessed or changed by another extend function.


\section{Algorithmic version}

Andromeda should be thought of as a programming language for deriving judgments. At the moment the language is untyped. We can hope to have it \emph{simply typed} one day.

\subsection{Syntax} % (fold)
\label{sub:prog-syntax}

Expressions:
%
\begin{equation*}
  \expr
  \begin{aligned}[t]
    \bnf   {}& \cmdType & & \text{universe}\\
    \bnfor {}& \x   &&\text{variable} \\
  \end{aligned}
\end{equation*}
%
Computations:
%
\begin{equation*}
  \cmd
  \begin{aligned}[t]
    \bnf   {}& \cmdReturn \expr              &&\text{pure expressions} \\
    \bnfor {}& \cmdLet{\x}{\cmd_1} \cmd_2    &&\text{let binding} \\
    \bnfor {}& \cmdAscribe{\cmd}{\expr}      &&\text{ascription} \\
    \bnfor {}& \cmdProd{x}{\expr} \cmd       &&\text{product}\\
    \bnfor {}& \cmdEq{\cmd}{\cmd}            &&\text{equality type} \\
    \bnfor {}& \cmdLam{\x}{\expr} \cmd       &&\text{$\lambda$-abstraction} \\
    \bnfor {}& \cmdApp{\expr}{\cmd}          &&\text{application} \\
    \bnfor {}& \cmdRefl \cmd                 &&\text{reflexivity}
  \end{aligned}
\end{equation*}

The result of a computation is a value, which is a pair $(e,T)$ where $e$ and $T$ are terms of type theory, as described in Section~\ref{sec:syntax}. The correctness guarantee which we want is that a computation only ever evaluates to derivable judgments.

% subsection prog-syntax (end)

\subsubsection{Operational semantics} % (fold)
\label{ssub:operational_semantics}

Operational semantics is given by \emph{two} versions of evaluation of computations, called \emph{inference} and \emph{checking}, of the forms:
%
\begin{align*}
  \text{Inference:}&\quad \evali{\ctxenv}{\cmd}{\e}{\T} \\
  \text{Checking:}&\quad  \evalc{\ctxenv}{\cmd}{\T}{\e}
\end{align*}
%
These are read as ``in the given context $\G$ and environment $\env$ command $\cmd$ infers that $\e$ has type $\T$'' and ``in the given context $\G$ and environment $\env$ command $\cmd$ checks that $\e$ has the given type $\T$.''

[EXPLAIN THAT AN ENVIRONMENT MAPS VARIABLES TO VALUES.]

\begin{mathpar}

  \infer[\rulename{check-infer}]
  {\evali{\ctxenv}{\cmd}{\e}{\U} \\
    \eqtypealg{\ctxenv}{\T}{\U}}
  {\evalc{\ctxenv}{\cmd}{\T}{\e}}

  \infer[\rulename{infer-type}]
  {}
  {\evali{\ctxenv}{\cmdReturn \Type}{\Type}{\Type}}

  \infer[\rulename{infer-product}]
  {\evalc \ctxenv {\cmd_1} \Type {\T_1} \\
    \evalc {\ctxextend \G \x {\T_1};\, \env} {\cmd_2} \Type {\T_2}}
  {\evali \ctxenv {\cmdProd \x {\cmd_1} {\cmd_2}} {\Prod \x {\T_1} {\T_2}} \Type}

  \infer[\rulename{infer-eq}]
  {\evali \ctxenv {\cmd_1} {\e_1} \T \\
    \evalc \ctxenv {\cmd_2} \T {\e_2}}
  {\evali \ctxenv {\cmdEq {\cmd_1} {\cmd_2}} {\JuEqual {\T} {\e_1} {\e_2}} \Type}

  \infer[\rulename{infer-ascription}]
  {\evalc \ctxenv \expr \Type \T \\
    \evalc \ctxenv \cmd \T \e}
  {\evali \ctxenv {\cmdAscribe \cmd \expr} \e \T}

\end{mathpar}

Inference of $\cmdEq{\cmd_1} {\cmd_2}$ keeps the type of the first argument.

Ascription only has an infer rule, and will always switch to a checking phase. It breaks the inward information flow and has to use the check-infer when encountered during checking.

\begin{mathpar}

  \infer[\rulename{infer-var}]
  {\env(\x) = (\e, \T)}
  {\evali{\ctxenv}{\cmdReturn \x}{\e}{\T}}

  % supposedly the user annotated the lambda, so we should use the type \T_1
  % which we get out of \expr in the recursive call, instead of \U_1
  \infer[\rulename{check-$\lambda$-tagged}]
  {\tywhnfs \ctxenv \U {\Prod \x {\U_1} {\U_2}} \\
    \evalc \ctxenv \expr \Type {\T_1} \\
    \eqtypealg \ctxenv {\T_1} {\U_1} \\
    \evalc {\ctxextend \G \x {\T_1};\, \env} \cmd {\U_2} \e}
  {\evalc \ctxenv {\cmdLam \x \expr \cmd} \U {\lam \x {\U_1} {\U_2} \e}}
  % XXX should the result be (x:U1)->U2 or (x:T1)->U2?

  \infer[\rulename{check-$\lambda$-untagged}]
  {\tywhnfs \ctxenv \U {\Prod \x {\U_1} {\U_2}} \\
    \evalc {\ctxextend \G \x {\U_1};\, \env} \cmd {\U_2} \e}
  {\evalc \ctxenv {\cmdLamCurry \x \cmd} \U {\lam \x {\U_1} {\U_2} \e}}

  \infer[\rulename{infer-$\lambda$}]
  {\evalc \ctxenv \expr \Type {\U_1} \\
    \evali {\ctxextend \G \x {\U_1};\, \envextend \env \x \x {\U_1}} \cmd \e {\U_2}}
  {\evali \ctxenv {\cmdLam \x \expr \cmd} {\lam \x {\U_1} {\U_2} \e} {\Prod \x {\U_1} {\U_2}}}

  \infer[\rulename{infer-app}]
  {\evali{\ctxenv}{\expr}{\e_1}{\T} \\
   \tywhnfs{\ctxenv}{\T}{\Prod{\x}{\U_1} \U_2} \\
   \evalc{\ctxenv}{\cmd}{\U_1}{\e_2}
  }
  {\evali
    {\ctxenv}
    {\cmdApp{\expr}{\cmd}}
    {\app{\e_1}{\x}{\U_1}{\U_2}{\e_2}}
    {\subst{\U_2}{\x}{\e_2}}
  }

  \infer[\rulename{check-app-non-dep}]
  {\evali \ctxenv \cmd {\e_2} \U \\
    \evalc \ctxenv \expr {\Prod \_ \U \T} {\e_1}}
  {\evalc \ctxenv {\cmdApp \expr \cmd} \T
    {\app{\e_1} \_ \U \T {\e_2}}}

  \infer[\rulename{infer-refl}]
  {\evali{\ctxenv}{\cmd}{\e}{\T}}
  {\evali{\ctxenv}{\cmdRefl \cmd}{\juRefl{\T}{\e}}{\JuEqual{\T}{\e}{\e}}}

  \infer[\rulename{check-refl}]
  {\tywhnfs{\ctxenv}{\T}{\JuEqual{\U}{\e_1}{\e_2}} \\
   \evalc{\ctxenv}{\cmd}{\U}{\e} \\
   \eqtermalg{\ctxenv}{\e}{\e_1}{\U} \\
   \eqtermalg{\ctxenv}{\e}{\e_2}{\U}
 }
  {\evalc{\ctxenv}{\cmdRefl \cmd}{\T}{\juRefl \T \e}}

  \infer[\rulename{check-let}]
  {\evali \ctxenv {\cmd_1} {\e_1} \U \\
  \evalc {\G;\, \envextend \env \x \e \U} {\cmd_2} \T {\e_2}}
  {\evalc \ctxenv {\cmdLet \x {\cmd_1} \cmd_2} \T {\e_2}}

  \infer[\rulename{infer-let}]
  {\evali \ctxenv {\cmd_1} {\e_1} \U \\
  \evali {\G;\, \envextend \env \x \e \U} {\cmd_2} {\e_2} \T}
  {\evali \ctxenv {\cmdLet \x {\cmd_1} \cmd_2} {\e_2} \T}

\end{mathpar}

TODO: check the freshness (and other side-conditions?).

% subsubsection operational_semantics (end)

archive/doc/2015-05 - ETT theory/eval.tex


\section{3D model fitting}
The model optimization stage refines model parameters to match the silhouette sequence $\mathcal S$. The procedure defined here is inspired by the human reconstruction method of SMALify~\cite{bogo16keep} (defined in detail in \Cref{chap:relwork}) and the non-automatic quadruped fitting method presented in 3D Menagerie (3DM) ~\cite{zuffi2017menagerie}. The technique presented in this section can be viewed as an extension of these approaches to input video sequences.

% SMALR exploited this fact (simultaneous fitting) in tangential work to ours.
A naive 3D model fitting implementation would be to simple apply 3DM independently to each of the $N$ video frame to yield a set of pose parameters $\seq{\pose}{t}{1}{N}$, shape parameters $\seq{\shape}{t}{1}{N}$ and position parameters $\seq{\posn}{t}{1}{N}$. However, fitting to a video sequence rather than single frames offers additional opportunities to constrain the challenging monocular 3D reconstruction task. For example, video sequences typically offer multiple views of the animal subject, although the animal's limb positions often change between frames. However, the animal's \emph{shape} characteristics (such as height, body proportions etc.) can be relied upon to remain largely consistent between frames. This fact is exploited through an extension that learns a single set of \emph{global} shape parameters $\shape$ and is assigned to across all frames $\shape_{t} := \shape$. Another benefit offered by video is the opportunity to constrain inter-frame subject motion. Assuming a reasonable framerate, it is expected that the animal's pose and position parameters should vary only slightly between successive frames. This intuition is characterized in \Cref{eq:temporal-energy}.

The following section defines the 4 energy terms used in the optimization:

\ss{Silhouette energy.}
The silhouette energy $\E{sil}$ compares the 3D animal model to the silhouette image according to the L2 distance between the OpenDR rendered binary image and the input silhouette $S_{t}$:

\begin{equation}
\E{sil}(\posn_{t}, \pose_{t}, \shape; S_{t}) = \lVert S_{t} - R\bigl(\posn_{t} * \verts(\pose_{t}, \shape)\bigr) \rVert
\end{equation}

\ss{Unimodal Prior energy.}
The prior term $\E{prior}$ encourages the regressed shape and pose parameters to remain close to a those in the combined artist traininthose in our set of artist 3D dog meshes.

% \begin{equation}
%     \L{pose}(\pose) = (\pose - \meanpose)^T \pose_cov^{-1} (\pose - \meanpose)
% \end{equation}

% \begin{equation}
%     \L{uni-shape}(\beta) = (\beta - \meanbeta)^T \beta_cov^{-1} (\beta - \meanbeta)
% \end{equation}

The Mahalanobis distance is used to encourage the model to remain close to: (1) a distribution over shape coefficients given by the mean and covariance of SMAL training samples of the relevant animal family, (2) a distribution of pose parameters built over a walking sequence. The final term ensures the pose parameters remain within set limits.
\begin{equation}
\E{lim}(\pose_{t}) = \max\{\pose_{t} - \pose_{\text{max}}, 0\} + \max\{\pose_{\text{min}} - \pose_{t}, 0\}.
\end{equation}

\ss{Joints energy.}
The joints energy $\E{joints}$ compares the rendered model joints to the OJA predictions, and therefore must account for missing and incorrect joints.  It is used primarily to stabilize the nonlinear optimization in the initial iterations, and its importance is scaled down as the silhouette term begins to enter its convergence basin.

\begin{equation}
\E{joints}(\posn_{t}, \pose_{t}, \shape; X^{*}) =
\lVert X^{*} - \posn_{t} * \verts(\pose_{t},\shape)\jointselect_{t}(:,j) \rVert
\end{equation}

\ss{Temporal energy.}
The optimizer for each frame is initialized to the result of that previous. In addition, a simple temporal smoothness term is introduced to penalize large inter-frame variation:
\begin{equation}
\E{temp}(\posn_{t}, \pose_{t}) = (\posn_{t} - \posn_{t+1})^2 + (\pose_{t} - \pose_{t+1})^2
\end{equation}\label{eq:temporal-energy}

% TODO: Maybe some more here?
The optimization is via a second order dogleg method~\cite{lourakis2005levenberg}.


Sign Language Recognition is a field in the intersection of computer vision and language translation that seeks to create systems capable of translating videos of people speaking in sign language into text.

In recent years, new advances in machine learning using models such as convolutional and recurrent neural networks have improved our ability to tackle complex recognition problems such as speech recognition,  image classification  or object detection\cite{Goodfellow2016DL}. These advances are fueled by a combination   of improvements in three areas; better datasets, better models, and more compute power. While the last two are mostly independent of a particular field, the availability of quality datasets for a given field limits the application of these new advances.  For example, common image classification datasets such as MNIST, CIFAR10, CIFAR100 and ImageNet contain  thousands of examples per class \cite{cubuk2019autoaugment}.

The process of recognizing a sign language consists of several steps, ranging from image preprocessing, body part detection, facial expression recognition, handshape recognition,  language modeling and language translation. Of these steps, handshape recognition plays the most crucial role in the interpretation of signs\cite{koller16,ronchetti2016sign}. However, sign language recognition cannot currently take full advantage  of state-of-the-art models, since  the availability of labeled, quality data for training models is very limited \cite{koller16}. Lack of data also impairs the development of accurate handshape recognition models \cite{koller16}.

In particular, Convolutional Neural Networks (CNN), a type of neural network that takes advantage  of convolutional layers to learn arbitrary convolutional filters, have proven very effective at image classification \cite{Goodfellow2016DL}, including the classification of handshapes in images \cite{quiroga2017study}.  However, in most  applications, convolutional neural networks are trained using  thousands of images per class.  In handshape recognition tasks, the datasets are considerably smaller and of lower quality, and therefore the performance of the models suffers accordingly \cite{koller16,tang2015real,quiroga2017study}.

In this work we propose to evaluate and compare new methods devoted to deal with small datasets in order to improve the current state-of-the-art in hand shape recognition for sign language.

Our approach consists of combining and comparing two different techniques for improving model performance in these conditions: data augmentation   and prototypical networks for few shot learning and semi supervised learning. Our data augmentation scheme consists of basic augmentation operators such as rotations, translations  and crops.  We compare this  with new technique approach.

In the following subsection we summarize previous efforts on training CNN on handshape datasets. Section \ref{sec:datasetsmodels} describes the datasets and models  we employed in our experiments,  which are detailed along with results in Section \ref{sec:experiments},  and Section \ref{sec:conclusion}  contains the conclusion of our work.

\subsection{Related Work}

Recent  years have seen the rise in the use of deep learning models for sign language recognition, specifically the use of convolutional neural networks to extract image features or directly classified hand images. \cite{koller16}  trained a  CNN to recognize handshapes  from the  RWTH handshape dataset,  which contains 3200 labeled samples and 50 different classes.  The model was based on a pre-trained network with a VGG architecture, and employed a semi-supervised scheme to take advantage of approximately  one million weakly labeled images, achieving an accuracy of 85.50\%. This constitutes the first attempt at adapting a model to overcome the low availability of labeled images for training. \cite{Ronchetti2016}  employed a radon transform as a feature for an ad hoc classifier that employed clustering as a quantization step and K nearest  neighbors  for the final classification. They tested the model on the LSA16 dataset,  which contains only 800 examples, obtaining an accuracy of 92.3\%. \cite{quiroga2017study}  evaluated several CNNs on the LSA16 and RWTH datasets, including both  vanilla and pre-trained models. The use of pretrained models helps to alleviate the lack of labeled data, since pretraining the convolutional filters establishes a prior that a further classifier can exploit for handshape recognition. This work is the second and last instance we found where a specific strategy was employed to alleviate the lack of data. Their best models of an accuracy of 95.92\% for LSA16 and 82.88\%  for RWTH. \cite{ciarp2018} trained a simple neural network to classify a new dataset they created, which contains 6000 examples and 10 classes, reaching an accuracy of 99.20\%. \cite{tang2015real} train a CNN on a custom dataset with 36 classes, 8 subjects and 57000 sample images. However, the samples correspond to video sequences and therefore are highly correlated;  while there are approximately 2000 images per class, there are only eight image sequences, one for each subject. Each of this image sequences  contains approximately 250 images  which are highly correlated,  and therefore it is best to consider the dataset as having eight image sequences per class. They obtained an accuracy of 94.17\%, \cite{ameen2017fingerspelling} trained a simple CNN with only 6 layers using the ASL Finger spelling dataset, obtaining an accuracy of 80.34\%. The dataset consists of 60000 images of 25 different classes, but they were captured as videos so they are also highly correlated as in the previous case. \cite{barros14multichannel} employed the Jochen Triesch Database (JTD), which contains only 10 classes and  72 samples per class, as well as the NAO Camera Hand Posture Database, which contains 4 classes and 400 examples per class. They trained a simple CNN with a multichannel image containing the results of the Sobel operator as input, obtaining an F-score of 94\%  and  98\% in  each dataset perspective. \cite{alani2018peru}  trained a deep CNN on the Hand Gesture Dataset LPD,  which contains 3250 images of only 6 classes, obtaining an accuracy of 99.73\%.

This brief review confirms our previous statement that  while CNN are being consistently applied to handshape recognition tasks, most of these datasets are small and ad hoc, that is, recorded specifically for the purpose of testing a single model and not developed with the intent of providing a benchmark and complete training set for handshape recognition models. It is also worth noticing that some datasets are so small that it is very easy to obtain near-perfect performance with simple models. Also, many datasets are not readily available,  given that the authors have not publish the data and do not provide any means of obtaining it.  We note that the RWTH and LSA16 are both publicly available and current models have been shown to achieve less than perfect accuracy for them.  While the dataset in \cite{ciarp2018}  has been easily solved,  it is interesting because it targets general handshapes instead of those specific to sign language. We will call this dataset CIARP.


\documentclass[letterpaper]{article}

\usepackage[utf8]{inputenc}
\usepackage{fullpage}
\usepackage{nopageno}
\usepackage{amsmath}
\usepackage{amssymb}
\usepackage{tikz}

\usetikzlibrary{graphs,graphdrawing}
\usegdlibrary{trees}

\allowdisplaybreaks

\newcommand{\abs}[1]{\left\lvert #1 \right\rvert}

\begin{document}
\title{Notes}
\date{January 23, 2015}
\maketitle
skipping 1.4

a graph is connected if for all $u,v$ in $E(G)$ there is a $u-v$ path

how can you tell if a graph is connected with the adjacency matrix? raise it to powers until it hits a nonzero entry. but you have to raise to infinity to prove non connectedness. this is inefficient at best.

there is a very easy way to do this

what happens when graph is disconnected?
\tikz\path [graphs/.cd, nodes={shape=circle, draw, text=black,inner sep=1pt,outer sep=0pt}]
  graph [tree layout] { 1 -- {2 -- 3} -- 1; 4--5 }
  [shift=(0:1)];

\[A(G)=\left[\begin{array}{ccccc}
0&1&1&0&0\\
1&0&1&0&0\\
1&1&0&0&0\\
0&0&0&0&1\\
0&0&0&1&0\\
\end{array}\right]\]

notice blocks of zeros on upper right and lower left

this depends on vertex labelling, note homework problem on isomorphic graphs and adjacency matrices

reduced row echelon form? determine negates when you switch columns or rows? same eigenvalues (?unsure). spectrum of graph

\section*{definition}
$k(G)$ is the number of components of a graph

\subsection*{example}
from above, $k(G)$ is 2

if $G$ is connected $k(G)=1$

\begin{description}
\item[cut vertex]
vertex $v$ such that $k(G)<k(G-v)$
\subsubsection*{example}
\tikz\path [graphs/.cd, nodes={shape=circle, draw, text=black,inner sep=1pt,outer sep=0pt}]
  graph [tree layout] { {1 -- 9}--8--7--6--5;1--{8--2}--1;8--3--6;{7--3};6--{4--5} }
  [shift=(0:1)];

8 and 6 are cut vertices
\item[nonseparable]
a connected graph with no cut vertices
\end{description}
\section*{theorem}
if $G$ is nonseparable and is simple and $|G|\ge 3$ then every pair of vertices lies on a cycle.

another way of thinking of this is that there are two paths between any two vertices.

\subsubsection*{proof}
picture:

\tikz\path [graphs/.cd, nodes={shape=circle, draw, text=black,inner sep=1pt,outer sep=0pt}]
  graph [tree layout] {  }
  [shift=(0:1)];
\begin{tikzpicture}[main_node/.style={circle,draw,text=black,inner sep=1pt,outer sep=0pt]}]

  \node[main_node] (1) at (-1,-1) {u};
  \node[main_node] (2) at (1,-1) {v};
  \draw (1) to[out=45,in=135] (2);
  \draw (1) to[out=90,in=215] (2);
  \draw (1) to[out=-45,in=90] (2);
\end{tikzpicture}

$G$ has no cut vertices and $|G|\ge 3$ since $G$ is connected, there is a $u-v$ path $P$. Let $\mathcal{P}=\{p_1,\dots,p_r\}$ be all the $u-v$ paths different from $P$. why is $\mathcal{P}\ne \emptyset$? nonseperability

\begin{tikzpicture}[main_node/.style={circle,draw,text=black,inner sep=1pt,outer sep=0pt]}]

  \node[main_node] (1) at (-1,-1) {u};
  \node[main_node] (2) at (1,-1) {w};
  \node[main_node] (3) at (3,-1) {v};
  \draw (1) to[out=45,in=135] (2);
  \draw (1) to[out=90,in=90] (2);
  \draw (1) to[out=0,in=180] (2);
  \draw (1) to[out=-90,in=-90] (2);
  \draw (1) to[out=-45,in=-135] (2);
  \draw (2) to[out=45,in=135] (3);
  \draw (2) to[out=90,in=90] (3);
  \draw (2) to[out=0,in=180] (3);
  \draw (2) to[out=-90,in=-90] (3);
  \draw (2) to[out=-45,in=-135] (3);
\end{tikzpicture}

if $P_i\cap P=\{u,v\}$ for some $i$, then we are done. if $P_i\cap P\ni w\forall i,$ then $w$ is a cut vertex. so
$\not\exists w\in P_i\cap P\forall i$.
let $v_i\in P_i\cap P\not\ni v_j\in P_j\cap P\not\ni v_i$

$\qquad
\quad
P_1
\qquad
\qquad
\qquad
\qquad
\qquad
P_2$

\begin{tikzpicture}[main_node/.style={circle,draw,text=black,inner sep=1pt,outer sep=0pt]}]
  \node[main_node] (1) at (-1,-1) {u};
  \node[main_node] (2) at (1,-1) {$v_i$};
  \node[main_node] (3) at (3,-1) {$v_j$};
  \node[main_node] (4) at (5,-1) {v};
  \draw (1) to[out=45,in=135] (2);
  \draw (2) to[out=-45,in=215] (4);
  \draw (1) to[out=-45,in=215] (3);
  \draw (3) to[out=45,in=135] (4);
\end{tikzpicture}

{\bfseries claim:} we can choose $v_i,v_j$ such that $\{v_i,v_j\}\le N_G(u)$
{\bfseries proof:} by nonsep $\deg(u)\ge 2$. if every $u-v$ path used edge $uw$ then w is a cut verte, therefore there are at least two $u-v$ paths starting from $u$ going through  distinct neighbors.

fromthe claim, let $v_i,v_j$ be as before. then we have
\tikz\path [graphs/.cd, nodes={shape=circle, draw, text=black,inner sep=1pt,outer sep=0pt}]
  graph [tree layout] { 1 -- {2 -- 3} -- 4 -- 1; 5 }
  [shift=(0:1)];

$vi=1, v_j=3, u=2, v=3$

repeat for $v_i, v_j$ to find two disjoint $u-v$paths making a cycle

\section*{corollary 1}
a connected graph $G$ of order 3 or more is nonsep  iff every pair of vertices has two internally disjoint paths between them

\section*{corollary 2}
let $u,v$be two distinct vertices in a nonseparable graph $G$. if $H$ is obtained by  adding a vertex to $G$ and connecting it to $u$ and $v$ $G$ then $H$ is nonsep

\section*{corollary 3}
if $G$ is nonsep and order 4 or more and $u,v\subseteq V(G)$ with $|U|=|V|=2$ and $U\cap V=\emptyset$ then $G$ contains two internally disjoint paths from vertices in $U$ to vertices in $V$.

\subsection*{internally disjoint:}
two$u-v$ paths $P_1$ and $P_2$ are internally disjoint if $P_1\cap P_2=\{u,v\}$
\end{document}