(*#########################################################################*)
(*#                                                                       #*)
(*#   StringTheory.m : Mathematica package to perform tensor calculations #*)
(*#                in string theory. Type '?Command' for help on          #*)
(*#                individual commands.                                   #*)
(*#                                                                       #*)
(*#########################################################################*)

(*:Title: StringTheory.m  *)

(*:Author: Bob Bacus *)

(*:Copyright: Copyright 1997, Bob Bacus *)

(*:Package Version: 1.0 *)

(*:Mathematica Version: 2.2.1 *)

(*: Summary: This package contains functions to simplify string theory
             calculations. *)

(*:Keywords: string theory *)

(*:Discussion: *)

(*:Context: StringTheory.m *)

(*:Source: *)

(*:History: *)

(*:Limitations: *)

Print[" "]
Print["#######################################################################"]
Print["#                                                                     #"]
Print["# StringTheory.m : Mathematica package to perform tensor calculations #"]
Print["#             in string theory. Type '?Command' for help on           #"]
Print["#             individual commands.                                    #"]
Print["#                                                                     #"]
Print["# Commands : rF, iF, rG, iG, X, DX, Dxs, Dxt, h, T, DT, DTs, DTt,     #"]
Print["#            dv, v, UseFunction                                       #"]
Print["#                                                                     #"]
Print["#######################################################################"]
<<Tensor.m

(*---------------------------------------------*)
(*| Create functions F[z] and G[z], separated |*)
(*| into real and imaginary parts;            |*)
(*---------------------------------------------*)
UseFunction[number_]:=Which[
      (number == 1),
      ( rF[s_,t_,p_]:=(s^2+t^2)^(p/2)*Cos[p*ArcTan[s/t]];
        iF[s_,t_,p_]:=(s^2+t^2)^(p/2)*Sin[p*ArcTan[s/t]];
        rG[s_,t_,q_]:=-(s^2+t^2)^(q/2)*Cos[q*ArcTan[s/t]];
        iG[s_,t_,q_]:=-(s^2+t^2)^(q/2)*Sin[q*ArcTan[s/t]];
        Print["\nCurrently defined functions are: Torus Knots\n"] ),
      (number == 2),
      ( rF[s_,t_,p_]:=Exp[p*Pi*t]*Cos[Pi*p*s];
        iF[s_,t_,p_]:=Exp[p*Pi*t]*Sin[Pi*p*s];
        rG[s_,t_,q_]:=Exp[q*Pi*t]*Cos[Pi*q*s];
        iG[s_,t_,q_]:=Exp[q*Pi*t]*Sin[Pi*q*s];
        Print["\nCurrently defined functions are: Closed strings (type V)\n"]  ),
      (number == 3),
      ( rF[s_,t_,p_]:=Cosh[p*Pi*t]*(Cos[p*Pi*s]-Sin[p*Pi*s]);
        iF[s_,t_,p_]:=Sinh[p*Pi*t]*(Cos[p*Pi*s]+Sin[p*Pi*s]);
        rG[s_,t_,q_]:=-Cosh[q*Pi*t]*(Cos[q*Pi*s]+Sin[q*Pi*s]);
        iG[s_,t_,q_]:=Sinh[q*Pi*t]*(Cos[q*Pi*s]-Sin[q*Pi*s]);
        Print["\nCurrently defined functions are: Closed strings (type B)\n"]  ),
      (number == 4),
      ( rF[s_,t_,p_]:=ComplexExpand[Re[(t+I*s)^p]];
	iF[s_,t_,p_]:=ComplexExpand[Im[(t+I*s)^p]];
	rG[s_,t_,q_]:=-ComplexExpand[Re[(t+I*s)^q]];
	iG[s_,t_,q_]:=-ComplexExpand[Im[(t+I*s)^q]];
	Print["\nCurrently defined functions are: Torus Knots (alternate expression)\n"] )]

UseFunction::usage="UseFunction[number] switches between a predefined
set of functions F[z] and G[z]. Currently defined functions are;\n
        1 - Torus Knots\n
        2 - Closed strings (type V)\n
        3 - Closed strings (type B)\n
        4 - Torus Knots (alternate expression)"

rF::usage="rF gives the real part of a function F[z], where z is a
complex variable (z=t+I*s)."

iF::usage="iF gives the imaginary part of a function F[z], where z is a
complex variable (z=t+I*s)."

rG::usage="rG gives the real part of a function G[z], where z is a
complex variable (z=t+I*s)."

iG::usage="iG gives the imaginary part of a function G[z], where z is a
complex variable (z=t+I*s)."

(*-------------------------------------*)
(*| Define the string instanton X[mu] |*)
(*-------------------------------------*)
X[s_,t_,p_,q_]:= Simplify[{iF[s,t,p],rF[s,t,p],rG[s,t,q],iG[s,t,q]}]

X::usage="X is a vector which describes the embedding of the 2D worldsheet
in the 4D spacetime."

XR[s_,t_,p_,q_]:= Simplify[{iF[s,t,p]/.Solve[iG[s,t,q] == l,t],
 rF[s,t,p]/.Solve[iG[s,t,q] == l,t], rG[s,t,q]/.Solve[iG[s,t,q] == l,t], l}]

XR::usage="XR is the vector X with the proper time replaced."

(*----------------------------------*)
(*| Define the derivative of X[mu] |*)
(*----------------------------------*)
Dxs[s_,t_,p_,q_]:=Simplify[D[X[s,t,p,q],s]]

Dxs::usage="Dxs is the derivative of the vector field X with respect to s."

Dxt[s_,t_,p_,q_]:=Simplify[D[X[s,t,p,q],t]]

Dxt::usage="Dxt is the derivative of the vector field X with respect to t."

DX[s_,t_,p_,q_]:= {D[X[s,t,p,q],s],D[X[s,t,p,q],t]}

DX::usage="DX is a rank 2 tensor which gives the derivative of the vector
field X."

(*---------------------------------------------*)
(*| Define the metric tensor h using its eqm. |*)
(*---------------------------------------------*)
h[s_,t_,p_,q_]:= Simplify[DX[s,t,p,q].Transpose[DX[s,t,p,q]]]

h::usage="h is the 2D metric of the worldsheet, in terms of X."

sh[s_,t_,p_,q_]:=PowerExpand[Sqrt[Simplify[Det[h[s,t,p,q]]]]]

sh::usage="sh is the square root of the determinant of the 2D metric."

(*-------------------------------------*)
(*| Define the 2-D Levi-Civita tensor |*)
(*-------------------------------------*)
epsilon:= {{0,1},{-1,0}}

(*------------------------------*)
(*| Define the tensor T[mu,nu] |*)
(*------------------------------*)
T[s_,t_,p_,q_]:=Simplify[(Outer[Times,Dxs[s,t,p,q],Dxt[s,t,p,q]]-
                Outer[Times,Dxt[s,t,p,q],Dxs[s,t,p,q]])/
                PowerExpand[Sqrt[Simplify[Det[h[s,t,p,q]]]]]]

T::usage="T is the rank 2 tensor defined in terms of X[s,t]"

(*-------------------------------------*)
(*| Define the derivative of T[mu,nu] |*)
(*-------------------------------------*)
DTs[s_,t_,p_,q_]:=Simplify[Factor[D[T[s,t,p,q],s]]]
DTt[s_,t_,p_,q_]:=Simplify[Factor[D[T[s,t,p,q],t]]]
DT[s_,t_,p_,q_]:=Simplify[Factor[{D[T[s,t,p,q],s],D[T[s,t,p,q],t]}]]

(*--------------------------------------------------------------------*)
(*| dv[s,t,p,q] gives the integrand of the self-intersection number; |*)
(*| v[s,t,p,q] returns the self-intersection number.                 |*)
(*--------------------------------------------------------------------*)
dv[s_,t_,p_,q_]:=Simplify[Factor[TensorProduct[DT[s,t,p,q],{a,u,v},
                 DT[s,t,p,q],{a,u,v}]]]

dv::usage="dv is the self-intersection density."

v[s_,t_,p_,q_]:=(Integrate[Integrate[dv[s,t,p,q],{s,0,2*Pi}],
                {t,-Infinity,Infinity}])/(2*Pi)

v::usage="v returns the self-intersection number."

UseFunction[1]

Print[" "]