auxiliary/pss2-deriveBG-public.h

   1 * Part of the auxiliary files used in the production of the
   2 * paper
   3 *
   4 * Non-abelian Z-theory: Berends-Giele recursion for the alpha'
   5 * expansion of disk integrals
   6 *
   7 * in collaboration with Oliver Schlotterer.
   8 *
   9 * You can use this file as you wish, as long as you cite the
  10 * paper 1609.XXXX afterwards
  11 *
  12 * Copyright (c) 2016 Carlos R. Mafra
  13 *
  14
  15         Function tL, Dynkin, Word, L, R;
  16         Function V, TreeLevel;
  17         Function tmpF,tmpF1;
  18         CFunction Ordering;
  19
  20         Symbol zwgt;
  21         Indices e,f;
  22
  23 * ZZ() is the calligraphic Z, ie the BG current of 1/z
  24 * eg ZZ(1,2,3) = 1/z12z23
  25         CFunction Z(a),ZZ,Zint;
  26
  27 #procedure ZintToZZ()
  28
  29 * assume canonical ordering
  30         id Zint(1,...,'Npts',[p],?m) = Zint(?m);
  31         id Zint(1,?m,'Npts',?n,{'Npts'-1}) = sign_(nargs_(?m))*ZZ(1,?m)*ZZ({'Npts'-1},reverse_(?n));
  32         id ZZ(i?) = 1;
  33
  34 #endprocedure
  35
  36 #procedure DynkinBracket()
  37
  38 * Nested Lie brackets according to definition above Lemma 1.3 in
  39 * "Lie elements and an algebra associated with shuffles", R. Ree
  40
  41 * Dynkin(1,2) = Word(1,2) - Word(2,1)
  42 * Dynkin(1,2,3) = word expansion of [[1,2],3]
  43
  44         if (match(Word(?m)));
  45         print "error: Word() already present in DynkinBracket: %t";
  46         exit;
  47         endif;
  48
  49         repeat;
  50         id Dynkin(?m,j?,i?) = Dynkin(?m,j)*Word(i) - Word(i)*Dynkin(?m,j);
  51         endrepeat;
  52         id Dynkin(i?) = Word(i);
  53         chainin Word;
  54
  55 #endprocedure
  56
  57 #procedure StringTreeAmplitude(N)
  58 *
  59 * The local form of the string tree amplitude from 1106.2645
  60 *
  61 * input: TreeLevel(?m)
  62 * output: equation (5.1) of 1603.09731 where the ordering Sigma=?m
  63 *
  64 * Note that the implementation below is just a hack meant to be
  65 * used in the deriveBGcurrent-public.frm file. In particular,
  66 * note that the integrand is always considered in the canonical order
  67 * Do not use this function for other purposes unless you know what
  68 * you are doing.
  69
  70         if (match(tmpF(?m)));
  71         print "error: tmpF() already present in StringTreeAmplitude";
  72         exit;
  73         endif;
  74
  75         id once TreeLevel(?m) = Ordering(?m)*tmpF(2,...,{'N'-2});
  76         #call Permute(tmpF)
  77         id tmpF(?m) = tmpF(1,?m,{'N'-1});
  78         #call DeconcatenateN(tmpF,2)
  79         id tmpF(?m1)*tmpF(?m2) = V(?m1)*V(reverse_(?m2))*Zint(?m1,'N',?m2)*sign_(nargs_(?m1)-1);
  80
  81         id Ordering(?m)*Zint(?n) = Zint(?m,[p],?n);
  82
  83 #endprocedure
  84
  85 #procedure Permute(F)
  86 *
  87 * suggested by tueda at the FORM forum on 23.11.2015
  88 *
  89 * Replace F(1,2,3,...) with F(1,2,3,...) + permutations.
  90
  91 * There must be only one instance of F()
  92         if ((count('F',1) <= -1) || (count('F',1) >= 2));
  93                 print "Error: Permute does not work for : %t";
  94         exit;
  95         endif;
  96
  97         chainout 'F';
  98         shuffle 'F';
  99 #endprocedure
 100
 101 #procedure DeconcatenateN(F,n)
 102 *
 103 * Deconcatenate function F into n-partitions or all partitions when n==0
 104 *
 105 * n==0: F(1,2,3) --> F(1)*F(2)*F(3) + F(1,2)*F(3) + F(1)*F(2,3)
 106 * n==2: F(1,2,3) --> F(1,2)*F(3) + F(1)*F(2,3)
 107 *
 108         if (match(tmpF1(?m)));
 109                 print "Error: temp function already present: %t";
 110                 exit;
 111         endif;
 112
 113         if ((count('F',1) <= -1) || (count('F',1) >= 2));
 114                 print "Error: Deconc does not work for : %t";
 115                 exit;
 116         endif;
 117
 118         chainout 'F';
 119
 120         repeat id once 'F'(?m)*'F'(?n) =
 121         + 'F'(?m,?n)
 122         + tmpF1(?m)*'F'(?n)
 123         ;
 124
 125         id tmpF1(?m) = 'F'(?m);
 126
 127         #if 'n' == 0
 128 * do nothing, keep all partitions
 129         #else
 130 * keep only n-partitions (or up to n-partitions)
 131 *        if ((match('F'(?m))) && (count('F',1) != 'n'));
 132         if ((match('F'(?m))) && (count('F',1) > 'n'));
 133                 discard;
 134         endif;
 135         #endif
 136
 137 * remove trivial partition F(1,2,3) -> F(1,2,3)
 138         if ((count('F',1) == 1));
 139                 discard;
 140         endif;
 141
 142 #endprocedure