/** * This method calculates one-loop counterterms of the fourth order minimal * operator. */ public static void testMinimalFourthOrderOperator() { //TIME = 6.2 s Expression iK = Tensors.parseExpression("iK_a^b=d_a^b"); Expression K = Tensors.parseExpression("K^{lmcd}_a^{b}=" + "d_a^b*1/3*(g^{lm}*g^{cd}+ g^{lc}*g^{md}+ g^{ld}*g^{mc})"); Expression S = Tensors.parseExpression("S^lmpab=0"); Expression W = Tensors.parseExpression("W^{lm}_a^b=0*W^{lm}_a^b"); Expression N = Tensors.parseExpression("N^pab=0*N^pab"); Expression M = Tensors.parseExpression("M_a^b = 0*M_a^b"); Expression F = Tensors.parseExpression("F_lmab=F_lmab"); OneLoopInput input = new OneLoopInput(4, iK, K, S, W, N, M, F); OneLoopCounterterms action = OneLoopCounterterms.calculateOneLoopCounterterms(input); }
/** * This method calculates one-loop counterterms of the second order minimal * operator. */ public static void testMinimalSecondOrderOperator() { //TIME = 6.1 s Expression iK = Tensors.parseExpression("iK_a^b=d_a^b"); Expression K = Tensors.parseExpression("K^lm_a^b=d_a^b*g^{lm}"); Expression S = Tensors.parseExpression("S^lab=0"); Expression W = Tensors.parseExpression("W_a^b=W_a^b"); Expression F = Tensors.parseExpression("F_lmab=F_lmab"); OneLoopInput input = new OneLoopInput(2, iK, K, S, W, null, null, F); OneLoopCounterterms action = OneLoopCounterterms.calculateOneLoopCounterterms(input); }
/** * This method calculates one-loop counterterms of the second order minimal * operator in Barvinsky and Vilkovisky notation (Phys. Rep. 119 ( 1985) * 1-74 ). */ public static void testMinimalSecondOrderOperatorBarvinskyVilkovisky() { //TIME = 4.5 s //Phys. Rep. 119 ( 1985) 1-74 Expression iK = Tensors.parseExpression("iK_a^b=d_a^b"); Expression K = Tensors.parseExpression("K^lm_a^b=d_a^b*g^{lm}"); Expression S = Tensors.parseExpression("S^lab=0"); //here P^... from BV equal to W^... Expression W = Tensors.parseExpression("W_a^b=W_a^b-1/6*R*d_a^b"); Expression F = Tensors.parseExpression("F_lmab=F_lmab"); OneLoopInput input = new OneLoopInput(2, iK, K, S, W, null, null, F); OneLoopCounterterms action = OneLoopCounterterms.calculateOneLoopCounterterms(input); }
Expression iK = Tensors.parseExpression("iK_ab^cd = " + "(d_a^c*d_b^d+d_b^c*d_a^d)/2+" + "la/2*(" + "+d_b^d*n_a*n^c)" + "-la*g^cd*n_a*n_b"); Expression K = Tensors.parseExpression("K^lm_ab^cd = " + "g^lm*(d_a^c*d_b^d+d_b^c*d_a^d)/2" + "-la/(4*(1+la))*(" + "+d_b^d*d_a^m*g^cl)" + "+la/(2*(1+la))*g^cd*(d_a^l*d_b^m+d_a^m*d_b^l)"); Expression S = Tensors.parseExpression("S^p_{ab}^{cd}=0"); Expression W = Tensors.parseExpression("W_{ab}^{cd}=P_ab^cd" + "-la/(2*(1+la))*(R_a^c_b^d+R_a^d_b^c)" + "+la/(4*(1+la))*(" + "+d_b^c*R_a^d" + "+d_b^d*R_a^c)"); Expression P = Tensors.parseExpression("P_cd^lm = " + "R_c^l_d^m+R_c^m_d^l" + "+1/2*(" + "+(-d_c^l*d_d^m-d_c^m*d_d^l+g^lm*g_cd)*R/2"); W = (Expression) P.transform(W); Expression F = Tensors.parseExpression("F_lm^kd_pr = " + "R^k_plm*d^d_r+R^d_rlm*d^k_p");
Expression iK = Tensors.parseExpression("iK_ab^cd = " + "(d_a^c*d_b^d+d_b^c*d_a^d)/2-" + "la/2*(" + "-1/2*g_ab*g^cd" + "+2*ga*(ga*la-2*ga+2*la)*n_a*n_b*n^c*n^d"); Expression K = Tensors.parseExpression("K^lm_ab^cd = " + "g^lm*(d_a^c*d_b^d+d_b^c*d_a^d)/2" + "-la/(4*(1+la))*(" + "+(la-be)/(2*(1+la))*(g^cd*(d_a^l*d_b^m+d_a^m*d_b^l)+g_ab*(g^cl*g^dm+g^cm*g^dl))" + "+g^lm*g_ab*g^cd*(-1+(1+be)**2/(2*(1+la)))"); K = (Expression) Tensors.parseExpression("be = ga/(1+ga)").transform(K); Expression S = Tensors.parseExpression("S^p_{ab}^{cd}=0"); Expression W = Tensors.parseExpression("W_{ab}^{cd}=P_ab^cd" + "-la/(2*(1+la))*(R_a^c_b^d+R_a^d_b^c)" + "+la/(4*(1+la))*(" + "+d_b^c*R_a^d" + "+d_b^d*R_a^c)"); Expression P = Tensors.parseExpression("P_ab^lm =" + "1/4*(d_a^c*d_b^d+d_a^d*d_b^c-g_ab*g^cd)" + "*(R_c^l_d^m+R_c^m_d^l-g^lm*R_cd-g_cd*R^lm" P = (Expression) ExpandTransformation.expand(P, EliminateMetricsTransformation.ELIMINATE_METRICS, Tensors.parseExpression("R_{l m}^{l}_{a} = R_{ma}"), Tensors.parseExpression("R_{lm}^{a}_{a}=0"), Tensors.parseExpression("R_{l}^{l}= R"));
/** * This method calculates ghosts contribution to the one-loop counterterms * of the gravitational field in the non-minimal gauge. The gauge fixing * term in LaTeX notation: * <pre> * S_{gf} = -1/2 \int d^4 x \sqrt{-g} g_{\mu\nu} \chi^\mu \chi^\nu, * where * \chi^\mu = 1/\sqrt{1+\lambda} (g^{\mu\alpha} \nabla^\beta h_{\alpha\beta}-1/2 g^{\alpha\beta} \nabla^\mu h_{\alpha\beta}) * </pre> */ public static void testGravityGhosts() { Expression iK = Tensors.parseExpression("iK_a^b=d_a^b+gamma*n_a*n^b"); Expression K = Tensors.parseExpression("K^{lm}_a^{b}=d_a^b*g^lm-1/2*beta*(d_a^l*g^mb+d_a^m*g^lb)"); Expression S = Tensors.parseExpression("S^p^l_m=0"); Expression W = Tensors.parseExpression("W^{a}_{b}=(1+beta/2)*R^a_b"); Expression F = Tensors.parseExpression("F_lmab=R_lmab"); Expression beta = Tensors.parseExpression("beta=gamma/(1+gamma)"); iK = (Expression) beta.transform(iK); K = (Expression) beta.transform(K); S = (Expression) beta.transform(S); W = (Expression) beta.transform(W); OneLoopInput input = new OneLoopInput(2, iK, K, S, W, null, null, F); OneLoopCounterterms action = OneLoopCounterterms.calculateOneLoopCounterterms(input); }
/** * This method calculates one-loop counterterms of the vector field in the * non-minimal gauge. */ public static void testVectorField() { Expression iK = Tensors.parseExpression("iK_a^b=d_a^b+c*n_a*n^b"); Expression K = Tensors.parseExpression("K^{lm}_a^{b}=g^{lm}*d_{a}^{b}-k/2*(g^{lb}*d_a^m+g^{mb}*d_a^l)"); Expression S = Tensors.parseExpression("S^p^l_m=0"); Expression W = Tensors.parseExpression("W^{a}_{b}=P^{a}_{b}+(k/2)*R^a_b"); Expression F = Tensors.parseExpression("F_lmab=R_lmab"); Expression lambda = Tensors.parseExpression("k=gamma/(1+gamma)"); Expression gamma = Tensors.parseExpression("c=gamma"); iK = (Expression) gamma.transform(lambda.transform(iK)); K = (Expression) gamma.transform(lambda.transform(K)); S = (Expression) gamma.transform(lambda.transform(S)); W = (Expression) gamma.transform(lambda.transform(W)); OneLoopInput input = new OneLoopInput(2, iK, K, S, W, null, null, F); OneLoopCounterterms action = OneLoopCounterterms.calculateOneLoopCounterterms(input); }
Expression iK = Tensors.parseExpression( "iK^{ab}_{lm} = P^{ab}_{lm}-1/4*c*g_{lm}*g^{ab}+" + "(1/4)*b*(n_{l}*n^{a}*d^{b}_{m}+n_{l}*n^{b}*d^{a}_{m}+n_{m}*n^{a}*d^{b}_{l}+n_{m}*n^{b}*d^{a}_{l})+" + "c*(n_{l}*n_{m}*g^{ab}+n^{a}*n^{b}*g_{lm})" + "-c*b*n_{l}*n_{m}*n^{a}*n^{b}"); Expression K = Tensors.parseExpression( "K^{lm}^{ab}_{cd} = g^{lm}*P^{ab}_{cd}+" + "(1+2*beta)*((1/4)*(d^{l}_{c}*g^{a m}*d^{b}_{d} + d^{l}_{d}*g^{a m}*d^{b}_{c}+d^{l}_{c}*g^{b m}*d^{a}_{d}+ d^{l}_{d}*g^{b m}*d^{a}_{c})+" + "(1/4)*(g_{cd}*g^{l a}*g^{m b}+g_{cd}*g^{l b}*g^{m a})-" + "(1/4)*(g^{ab}*d^{l}_{c}*d^{m}_{d}+g^{ab}*d^{l}_{d}*d^{m}_{c})+(1/8)*g^{lm}*g_{cd}*g^{ab})"); Expression P = Tensors.parseExpression( "P^{ab}_{lm} = (1/2)*(d^{a}_{l}*d^{b}_{m}+d^{a}_{m}*d^{b}_{l})-(1/4)*g_{lm}*g^{ab}"); iK = (Expression) P.transform(iK); Tensors.parseExpression("c=(1+2*beta)/(5+6*beta)"), Tensors.parseExpression("b=-(1+2*beta)/(1+beta)") }; for (Expression cons : consts) { Expression F = Tensors.parseExpression("F_lmabcd=0");
UnitarySimplifyTransformation(final Tensor dimension, ChangeIndicesTypesAndTensorNames tokenTransformer) { //simplifications with SU(N) combinations ArrayList<Transformation> unitarySimplifications = new ArrayList<>(); if (dimension instanceof Complex) { Transformation nSub = parseExpression("N = " + dimension); for (ParseToken substitution : unitarySimplificationsTokens) unitarySimplifications.add((Transformation) nSub.transform(tokenTransformer.transform(substitution).toTensor())); } else for (ParseToken substitution : unitarySimplificationsTokens) unitarySimplifications.add((Transformation) tokenTransformer.transform(substitution).toTensor()); //all simplifications ArrayList<Transformation> simplifications = new ArrayList<>(); simplifications.add(EliminateMetricsTransformation.ELIMINATE_METRICS); simplifications.addAll(unitarySimplifications); this.unitarySimplifications = new TransformationCollection(simplifications); }
Expression iK = Tensors.parseExpression("iK_a^b=d_a^b+(2*c+Power[c,2])*n_a*n^b"); Expression K = Tensors.parseExpression("K^{lmcd}_a^{b}=" + "d_a^b*1/3*(g^{lm}*g^{cd}+ g^{lc}*g^{md}+ g^{ld}*g^{mc})" + "+1/12*(-2*k+Power[k,2])*(" + "+g^{cd}*d_a^l*g^{bm}" + "+g^{cd}*d_a^m*g^{bl})"); Expression S = Tensors.parseExpression("S^lmpab=0"); Expression W = Tensors.parseExpression("W^{lm}_a^b=" + "2*P_{a}^{b}*g^{lm}-2/3*R^lm*d_a^b" + "-k/2*P_a^l*g^mb" + "(R_a^lbm+R_a^mbl)" + "+1/2*(2*k-Power[k,2])*g^lm*R_a^b"); Expression N = Tensors.parseExpression("N^pab=0"); Expression M = Tensors.parseExpression("M_a^b = " + "P_al*P^lb-1/2*R_lmca*R^lmcb" + "+k/2*P_al*R^lb" + "+1/12*(4*k+7*Power[k,2])*R_lam^b*R^lm" + "+1/4*(2*k-Power[k,2])*R_almc*R^clmb"); Expression F = Tensors.parseExpression("F_lmab=R_lmab"); Expression lambda = Tensors.parseExpression("k=gamma/(1+gamma)"); Expression gamma = Tensors.parseExpression("c=gamma"); iK = (Expression) gamma.transform(lambda.transform(iK)); K = (Expression) gamma.transform(lambda.transform(K));
result[i++] = parseExpression("k1_{a}*k2^{a} = (1/2)*(-m1**2-m2**2+s)"); result[i++] = parseExpression("k3^{a}*k1_{a} = (1/2)*(m1**2+m3**2-t1)"); result[i++] = parseExpression("k4^{a}*k1_{a} = (1/2)*(m1**2-t2+m4**2)"); result[i++] = parseExpression("k5^{a}*k1_{a} = (1/2)*(-m1**2-m2**2-m3**2+s+t2-m4**2+t1)"); result[i++] = parseExpression("k3^{a}*k2_{a} = (1/2)*(-u1+m2**2+m3**2)"); result[i++] = parseExpression("k4^{a}*k2_{a} = (1/2)*(-u2+m2**2+m4**2)"); result[i++] = parseExpression("k5^{a}*k2_{a} = (1/2)*(u1-m1**2+u2-m2**2-m3**2+s-m4**2)"); result[i++] = parseExpression("k3_{a}*k4^{a} = (1/2)*(-u1-u2+2*m1**2+m3**2-s-t2+m4**2+2*m2**2-t1+m5**2)"); result[i++] = parseExpression("k3_{a}*k5^{a} = (1/2)*(-m1**2+u2-m2**2-m3**2+s+t2-m4**2-m5**2)"); result[i] = parseExpression("k5^{a}*k4_{a} = (1/2)*(u1-m1**2-m2**2-m3**2+s-m4**2+t1-m5**2)"); parseExpression("s = " + s.toString(Redberry)), parseExpression("t1 = " + t1.toString(Redberry)), parseExpression("t2 = " + t2.toString(Redberry)), parseExpression("u1 = " + u1.toString(Redberry)), parseExpression("u2 = " + u2.toString(Redberry)),
i = -1; } else coefficientsResults[++i] = Tensors.parseExpression(strLine);
Transformation nSub = parseExpression("N = " + dimension); for (ParseToken substitution : unitarySimplificationsTokens) unitarySimplifications.add((Transformation) nSub.transform(tokenTransformer.transform(substitution).toTensor()));
pairProduct = (Expression) parseExpression("N = " + dimension).transform(pairProduct); this.pairProduct = pairProduct;
Tensors.parseExpression("R_{l m}^{l}_{a} = R_{ma}"), Tensors.parseExpression("R_{lm}^{a}_{a}=0"), Tensors.parseExpression("F_{l}^{l}^{a}_{b}=0"), Tensors.parseExpression("R_{lmab}*R^{lamb}=(1/2)*R_{lmab}*R^{lmab}"), Tensors.parseExpression("R_{lmab}*R^{lmab}=4*R_{lm}*R^{lm}-R*R"), Tensors.parseExpression("R_{l}^{l}= R") };