% -*- mode: Noweb; noweb-code-mode: maple-mode -*-
\documentclass{article}

\usepackage[latin1]{inputenc}
\usepackage[T1]{fontenc}
\usepackage{noweb}
\usepackage{multicol}
\usepackage{amsmath}
\usepackage{amssymb}

\pagestyle{noweb}
\noweboptions{webnumbering}

\newcommand{\abs}[1]{\lvert #1\rvert}
\newcommand{\inp}[3][]{\left\langle #2,#3\right\rangle_{#1}}
\newcommand{\norm}[2][]{\left\lVert #2\right\rVert_{#1}}
\DeclareMathOperator{\SL}{\textsl{SL}}
\DeclareMathOperator{\Sl}{\mathfrak{sl}}
\DeclareMathOperator{\SO}{\textsl{SO}}
\DeclareMathOperator{\so}{\mathfrak{so}}

\begin{document}

@
\title{The HyperKähler Potential for an Exceptional Next-to-Minimal Orbit}
\author{Piotr Kobak and Andrew Swann}
\date{19th December, 1998}
\maketitle

\tableofcontents

\section*{About this Document}
This is a \texttt{noweb} file for \texttt{maple} input.  To get the
\LaTeXe\ formatted source file first run
\begin{verbatim}
  noweave -delay -index g2.nw > g2.tex
\end{verbatim}
and then process the resulting file with \LaTeX.  To get the \texttt{maple}
code, type
\begin{verbatim}
  notangle g2.nw > g2
\end{verbatim}

@
\section{Introduction}
The aim of these routines is to compute the hyperKähler potential for the
next-to-minimal orbit in~$G_2^{\mathbb C}$.  We know this orbit is of
cohomogeneity two and from that we can derive a formula for a candidate
almost complex structure~$J$.  To determine the potential it turns out that
it is enough to force $J^2=-1$.  (There is always the ambiguity of an
additive constant in the potential.)  The mathematics of this is described
in our joint paper.

<<*>>=
<<Header>>
<<Lie algebras>>
<<G2 embedded in SO7>>
<<Next-to-minimal orbit>>
@

\section{Lie Algebra Routines} 
First we provide some general routines for working in Lie algebras.

<<Lie algebras>>=
print(`Defining Lie algebra operations`);
with(linalg):
@ 

The Lie bracket in a matrix Lie algebra is $[X,Y]=XY-YX$.

<<Lie algebras>>=
Lb := proc (X::matrix,Y::matrix)
    evalm(X &* Y - Y &* X);
end: 
@ %def Lb

The natural inner products on a matrix Lie algebra is a multiple of minus
the trace of the product of matrices.  We call that multiple [[k^2]].  For
efficiency reasons, we evaluate the trace explicitly, to avoid doing an
unnecessary matrix multiplication, i.e., we use
\begin{equation*}
  \operatorname{Tr}(X Y) = \sum_{i,j} x_{ij} y_{ji}
\end{equation*}

<<Lie algebras>>=
MetricForm := proc(X::matrix,Y::matrix)
    local boundsx,boundsy,i,j,n,total;
    global k;
    boundsx := [op(2,eval(X))];
    boundsy := [op(2,eval(Y))];
    n := op([1,2],boundsx);
    if not(n=op([2,2],boundsx))
        or not(n=op([1,2],boundsy))
        or not(n=op([2,2],boundsy))
    then
        ERROR(`Arguments of`, procname,
        `need to be square matrices of the same size`);
    fi;
    total := 0;
    for i to n do
        for j to n do
            total := total + X[i,j]*Y[j,i];
        od;
    od;
    - k^2 * total;
end:
@ %def MetricForm

\section{$G_2$ and $\SO(7)$}

The Lie algebra~$\so(7,\mathbb C)$ is defined to be the set of $7\times 7$
matrices preserving a symmetric bilinear form.  For many purposes it is
actually convenient to take that bilinear form to be anti-diagonal.
Elements of $\so(7,\mathbb C)$ are then skew-symmetric about this
anti-diagonal.

<<G2 embedded in SO7>>=
print(`Embedding G2 in SO7`);
AntiDiagonal := matrix(7,7,0):
for i to 7 do
    AntiDiagonal[i,8-i]:=1;
od:
@ %def AntiDiagonal

The Lie algebra $\mathfrak g_2^{\mathbb C}$ has a subalgebra~$\Sl(3,\mathbb
C)$.  It splits as 
\begin{equation*}
  \mathfrak g_2^{\mathbb C} = \Sl(3,\mathbb C) \oplus (V + V^*),
\end{equation*}
where $V\cong\mathbb C^3$ is the fundamental representation
of~$\Sl(3,\mathbb C)$.  We embed $\mathfrak g_2^{\mathbb C}$
in~$\so(7,\mathbb C)$ by embedding each of these summands.

To embed $\Sl(3,\mathbb C)$, we consider the splitting
\begin{equation*}
  \mathbb R^7 = \mathbb R^3 \oplus \mathbb R \oplus \mathbb R^3.
\end{equation*}
The fundamental representation~$V$ is then $\mathbb R^3\oplus\mathbb R^3$
and we get $\Sl(3,\mathbb C)$ embedded in $\so(7,\mathbb C)$ as
\begin{equation*}
  A \mapsto
  \begin{pmatrix}
    A & 0 & 0\\
    0 & 0 & 0\\
    0 & 0 & -A^t
  \end{pmatrix}
  .
\end{equation*}

The following routine assumes that the matrix $A$ is trace-free.  The
procedure [[TrFree]] is provided below in [[<<Remove trace>>]] to make a
given matrix trace-free.

<<G2 embedded in SO7>>=
sl3 := proc(A)
    local Am,i,j,out;
    Am := convert(eval(A),matrix);
    if (not([op(2,eval(Am))]=[1..3,1..3])) then
        ERROR(`Argument of`, procname, `must be convertible to a 3x3 matrix`);
    fi;
    if not(trace(Am)=0) then
        print(`Warning: matrix passed to sl3 is not trace-free`);
    fi;
    out := matrix(7,7,0);
    for i from 1 to 3 do
        for j from 1 to 3 do
            out[i,j]:= Am[i,j];
            out[8-j,8-i]:= -Am[i,j];
        od;
    od;
    evalm(out);
end:
<<Remove trace>>
@ %def sl3

<<G2 embedded in SO7>>=
V10 := proc(L::list)
    local i,sqt2,out;
    if not(nops(L)=3) then
        ERROR(`Argument to`, procname, `must have 3 elements`);
    fi;
    out := matrix(7,7,0);
    <<square root of 2>>
    out[6,3] :=  L[1]/sqt2;
    out[5,1] :=  L[2]/sqt2;
    out[7,2] :=  L[3]/sqt2;
    out[5,2] := -out[6,3];
    out[7,3] := -out[5,1];
    out[6,1] := -out[7,2];
    for i from 1 to 3 do
        out[i,4] := L[i]:
        out[4,8-i] := -L[i]:
    od:
    evalm(out);
end:
@ %def V10

<<G2 embedded in SO7>>=
V01 := proc(L::list)
    local i,sqt2,out;
    if not(nops(L)=3) then
        ERROR(`Argument to`, procname, `must have 3 elements`);
    fi;
    out := matrix(7,7,0);
    <<square root of 2>>
    out[3,6] :=  L[1]/sqt2;
    out[1,5] :=  L[2]/sqt2;
    out[2,7] :=  L[3]/sqt2;
    out[2,5] := -out[3,6];
    out[3,7] := -out[1,5];
    out[1,6] := -out[2,7];
    for i from 1 to 3 do
        out[4,i] := L[i]:
        out[8-i,4] := -L[i]:
       od:
    evalm(out);
end:
@ %def V01

<<square root of 2>>=
sqt2 := sqrt(2);
@ %def sqt2

We make a matrix trace-free by adjusting the entry in the bottom right-hand
corner.

<<Remove trace>>=
TrFree := proc(A)
    local Am,bounds,rows,cols;
    Am := evalm(convert(A,matrix));
    bounds := [op(2,eval(Am))];
    rows := op([1,2],bounds);
    cols := op([2,2],bounds);
    if not(rows=cols) then
        ERROR(`Argument of`, procname, `not a square matrix`);
    fi;
    Am[rows,rows] := Am[rows,rows] - trace(Am);
    evalm(Am);
end:
@ %def TrFree

\section{Next-to-minimal Orbits}

<<Next-to-minimal orbit>>=
<<Base line>>
<<Real structure>>
<<Almost complex structure>>
<<Test J-squared>>
@ 

First define our base point~$X$.  [[s]] and [[t]] are real positive numbers.
<<Base line>>=
print(`Our base line is`);
X := evalm(
    sl3([[0,s,0],[0,0,0],[0,0,0]])
    + V10([t*sqrt(2),0,0]
    ));
@ %def X    

We work at an $X$ with real entries, so the real structure need not involve
complex conjugation.
<<Real structure>>=
Conj := proc(X::matrix)
    global AntiDiagonal;
    evalm( AntiDiagonal &* X &* AntiDiagonal);
end:
@ %def Conj

\subsection{The Candidate Almost Complex Structure}
The formula for the candidate almost complex structure~$J$ as given in our
paper is 
\begin{equation}
  \label{eq:J}
  \begin{split}
    J\xi_A
    & = -2 \rho_1 [X,\sigma \xi_A] \\
    & \quad+ 4 \rho_2 (2 [X,[\sigma X,[X,\sigma \xi_A]]] - [X,[X,[\sigma
    X,\sigma \xi_A]]])\\
    & \quad - 2\rho_{11} \inp{\sigma \xi_A}X [X,\sigma X]\\
    & \quad + 4\rho_{12}
    \begin{aligned}[t]
      \bigl(
      & \inp{\sigma \xi_A}{[X,[\sigma X,X]]} [X,\sigma X] \\
      &+ \inp{\sigma \xi_A}X [X,[\sigma X,[X,\sigma X]]]
      \bigr)
    \end{aligned}
    \\
    & \quad - 8 \rho_{22} \inp{\sigma \xi_A}{[X,[\sigma X,X]]} [X,[\sigma
    X,[X,\sigma X]]].
  \end{split}
\end{equation}
We need to optimise this a little for the implementation.  Quantities only
involving~$X$ should be assigned to global variables.  Those
involving~$\xi_A$ should be local variables in the routine for~$J$.

The first thing to notice is that the coefficient of~$\rho_2$ was rewritten
during our proof, and the original form
\begin{equation*}
      4\bigl( [X,[\sigma \xi_A,[X,\sigma X]]] + [X,[\sigma X,[X,\sigma
    \xi_A]]] \bigr)
\end{equation*}
is better here as it involves more global variables.

@
The global quantities are
\begin{align*}
  [[sX]] &:= \sigma X\\
  [[XsX]]&:= [X,\sigma X]\\
  [[XsXX]] &:= [X,[\sigma X,X]]\\
  [[XsXXsX]] &:= [X,[\sigma X,[X,\sigma X]]]
\end{align*}

<<Almost complex structure>>=
print(`Defining J`);
sX := Conj(X):
XsX := Lb(X,sX):
XsXX := evalm(-Lb(X,XsX)):
XsXXsX := Lb(X,Lb(sX,XsX)):
@ %def sX XsX XsXX XsXXsX

The quantities we can split off locally are
\begin{align*}
  [[sXiA]] &:= \sigma\xi_A\\
  [[XsXiA]] &:= [X,\sigma\xi_A]\\
  [[IpsXiAX]] &:= \inp{\sigma\xi_A}{X}\\
  [[IpsXiAXsXX]] &:= \inp{\sigma\xi_A}{[X,[\sigma X,X]]}.
\end{align*}
Again we will take $\xi_A$ to have only real entries.

<<Almost complex structure>>=
J := proc(XiA::matrix) 
    local sXiA, XsXiA, IpsXiAX, IpsXiAXsXX;
    global X, sX, XsX, XsXX, XsXXsX, f1, f2, f11, f12, f22;
    sXiA := Conj(XiA);
    XsXiA := Lb(X,sXiA);
    IpsXiAX := MetricForm(sXiA,X);
    IpsXiAXsXX := MetricForm(sXiA,XsXX);
    evalm(
        -2*f1*XsXiA
        +4*f2*Lb(X, evalm(
                            Lb(sXiA,XsX)
                            +Lb(sX,XsXiA)
                          )
                )
        -(2*(f11*IpsXiAX - 2*f12*IpsXiAXsXX)) * XsX
        +(4*(f12*IpsXiAX - 2*f22*IpsXiAXsXX)) * XsXXsX
        );
end:
@ %def J    

\subsection{When Do We Have an Almost Complex Structure?}
We provide various routines for finding when $J^2=-1$.  Firstly, as a
simple computation.

<<Test J-squared>>=
J2P := proc(xA::matrix)
    evalm(J(J(xA))+xA);
end:
@ %def J2P

Secondly, one can change variables in the derivatives to those with respect
to $s$ and $t$ instead of $\eta_1$ and~$\eta_2$.

It is tempting to automatically simplify the expression $J^2\xi_A+\xi_A$,
but as these are $7\times7$ matrices that would be very time consuming.  We
let the user do that we they want to.  However, mapping [[expand]] on to
the entries can help alot.

<<Test J-squared>>=
<<Change variables>>
J2stP := proc(xA)
    local out;
    global dsdt;
    out := subs(dsdt,J2P(xA));
    map(expand,out);
end:
@ %def J2stP

\section{Change of Variables}

The two main invariants are $\eta_1=\inp X{\sigma X}$ and $\eta_2=\inp
Y{\sigma Y}$, with $Y=[X,\sigma X]$.

<<Change variables>>=
print(`Computing change of variables`);
eta1 := simplify(MetricForm(X,Conj(X)));
eta2 := simplify(-MetricForm(XsX,XsX));
@ %def eta1 eta2

<<Change variables>>=
D1f := {  fs=diff( f(z1(s,t),z2(s,t)),s),
          ft=diff( f(z1(s,t),z2(s,t)),t)}:
D1f := subs( { D[1](f)(z1(s,t),z2(s,t))=f1,
        D[2](f)(z1(s,t),z2(s,t))=f2
      }, D1f ):
D1f := simplify(subs({z1(s,t)=eta1,z2(s,t)=eta2}, D1f)):
D1fst:=simplify(solve(D1f,{f1,f2})):
@ %def D1fst

<<Change variables>>=
D2f := { fss=diff(f(z1(s,t),z2(s,t)),s,s),
         fst=diff(f(z1(s,t),z2(s,t)),s,t),
         ftt=diff(f(z1(s,t),z2(s,t)),t,t)
        }:
D2f := subs({ D[1](f)(z1(s,t),z2(s,t))=f1,
              D[2](f)(z1(s,t),z2(s,t))=f2,
              D[1,2](f)(z1(s,t),z2(s,t))=f12,
              D[2,1](f)(z1(s,t),z2(s,t))=f12,
              D[1,1](f)(z1(s,t),z2(s,t))=f11,
              D[2,2](f)(z1(s,t),z2(s,t))=f22
            }, D2f):
D2f := simplify(subs({z1(s,t)=eta1,z2(s,t)=eta2}, D2f)):
D2f := subs(D1fst,D2f):
D2fst:=simplify(solve(D2f,{f11,f12,f22})):
@  %def D2fst

<<Change variables>>=
dsdt := D1fst union D2fst:
@ %def dsdt

\section{Heading}
This is general information of the top of the output file.

<<Header>>=
# g2
# Maple code for calculations of hyperKaehler potentials in the exceptional
# Lie algebra G2
# by
# Piotr Kobak and Andrew Swann
# 19th December, 1998
# 
# This code is generated from a noweb source file g2.nw
# See that for further description and comments.

@
\section*{List of Code Chunks}
\begin{multicols}{2}
  \nowebchunks
\end{multicols}

\section*{Index}
\begin{multicols}{3}
  \nowebindex
\end{multicols}

\nwenddocs{}
\end{document}