cc.redberry.physics.oneloopdiv.Benchmarks Maven / Gradle / Ivy
/*
* Redberry: symbolic tensor computations.
*
* Copyright (c) 2010-2013:
* Stanislav Poslavsky
* Bolotin Dmitriy
*
* This file is part of Redberry.
*
* Redberry is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Redberry is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Redberry. If not, see
* Machine:
* Processor family: Intel(R) Core(TM) i5 CPU M 430 @ 2.27GHz.
* -Xmx value : 3g.
* Max memory used: 1.2g.
* Java version: 1.7.0_03 HotSpot 64-bit server VM
*
* Benchmark results:
* Minimal second order : 2 s.
* Minimal fourth order : 2 s.
* Vector field : 19 s.
* Gravity ghosts : 19 s.
* Squared vector field : 313 s.
* Lambda gauge gravity : 612 s.
* Spin 3 ghosts : 920 s.
*
*
* Machine:
* Processor family: AMD Phenom(tm) II X6 1100T Processor
* -Xmx value : 3g
* Max memory used: 1.2g
* Java version: 1.7.0_04 HotSpot 64-bit server VM
*
* Benchmark results:
* Minimal second order : 1 s.
* Minimal fourth order : 1 s.
* Vector field : 14 s.
* Gravity ghosts : 14 s.
* Squared vector field : 219 s.
* Lambda gauge gravity : 521 s.
* Spin 3 ghosts : 627 s.
*
*
* @author Stanislav Poslavsky
*/
public final class Benchmarks {
private Benchmarks() {
}
private static final OutputStream dummyOutputStream = new OutputStream() {
@Override
public void write(int b) throws IOException {
}
};
private static final PrintStream defaultOutputStream = System.out;
private static void println(String str) {
defaultOutputStream.println(str);
}
public static void main(String[] args) {
//Processor family: Intel(R) Core(TM) i5 CPU M 430 @ 2.27GHz.
//-Xmx value : 3g.
//Max memory used: 1.2g.
//Java version: 1.7.0_03 HotSpot 64-bit server VM
//Benchmark results:
//
//Minimal second order : 2 s.
//Minimal fourth order : 2 s.
//Vector field : 19 s.
//Gravity ghosts : 19 s.
//Squared vector field : 313 s.
//Lambda gauge gravity : 612 s.
//Spin 3 ghosts : 920 s.
//Processor family: AMD Phenom(tm) II X6 1100T Processor
//-Xmx value : 3g
//Max memory used: 1.2g
//Java version: 1.7.0_04 HotSpot 64-bit server VM
//Benchmark results:
//
//Minimal second order : 1 s.
//Minimal fourth order : 1 s.
//Vector field : 14 s.
//Gravity ghosts : 14 s.
//Squared vector field : 219 s.
//Lambda gauge gravity : 521 s.
//Spin 3 ghosts : 627 s.
//suppressing output
System.setOut(new PrintStream(dummyOutputStream));
//burning JVM
burnJVM();
Timer timer = new Timer();
timer.start();
testMinimalSecondOrderOperator();
println("Minimal second order : " + timer.elapsedTimeInSeconds() + " s.");
timer.restart();
testMinimalFourthOrderOperator();
println("Minimal fourth order : " + timer.elapsedTimeInSeconds() + " s.");
timer.restart();
testVectorField();
println("Vector field : " + timer.elapsedTimeInSeconds() + " s.");
timer.restart();
testGravityGhosts();
println("Gravity ghosts : " + timer.elapsedTimeInSeconds() + " s.");
timer.restart();
testSquaredVectorField();
println("Squared vector field : " + timer.elapsedTimeInSeconds() + " s.");
timer.restart();
testLambdaGaugeGravity();
println("Lambda gauge gravity : " + timer.elapsedTimeInSeconds() + " s.");
timer.restart();
testSpin3Ghosts();
println("Spin 3 ghosts : " + timer.elapsedTimeInSeconds() + " s.");
timer.restart();
}
/**
* Warm up the JVM.
*/
public static void burnJVM() {
testVectorField();
for (int i = 0; i < 10; ++i)
testMinimalFourthOrderOperator();
}
static class Timer {
private long start, stop;
public Timer() {
}
void start() {
start = System.currentTimeMillis();
}
long elapsedTime() {
return System.currentTimeMillis() - start;
}
long elapsedTimeInSeconds() {
return (System.currentTimeMillis() - start) / 1000;
}
void restart() {
start();
}
}
/**
* This method calculates one-loop counterterms of the vector field in the
* non-minimal gauge.
*/
public static void testVectorField() {
CC.setDefaultOutputFormat(OutputFormat.RedberryConsole);
Tensors.addSymmetry("P_\\mu\\nu", IndexType.GreekLower, false, 1, 0);
Expression KINV = Tensors.parseExpression("KINV_\\alpha^\\beta=d_\\alpha^\\beta+\\gamma*n_\\alpha*n^\\beta");
Expression K = Tensors.parseExpression("K^{\\mu\\nu}_\\alpha^{\\beta}=g^{\\mu\\nu}*d_{\\alpha}^{\\beta}-\\lambda/2*(g^{\\mu\\beta}*d_\\alpha^\\nu+g^{\\nu\\beta}*d_\\alpha^\\mu)");
Expression S = Tensors.parseExpression("S^\\rho^\\mu_\\nu=0");
Expression W = Tensors.parseExpression("W^{\\alpha}_{\\beta}=P^{\\alpha}_{\\beta}+(\\lambda/2)*R^\\alpha_\\beta");
Expression F = Tensors.parseExpression("F_\\mu\\nu\\alpha\\beta=R_\\mu\\nu\\alpha\\beta");
Expression lambda = Tensors.parseExpression("\\lambda=gamma/(1+gamma)");
Expression gamma = Tensors.parseExpression("\\gamma=gamma");
KINV = (Expression) gamma.transform(lambda.transform(KINV));
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, KINV, K, S, W, null, null, F);
OneLoopCounterterms action = OneLoopCounterterms.calculateOneLoopCounterterms(input);
}
/**
* This method calculates one-loop counterterms of the squared vector field
* in the non-minimal gauge.
*/
public static void testSquaredVectorField() {
CC.setDefaultOutputFormat(OutputFormat.RedberryConsole);
Tensors.addSymmetry("P_\\mu\\nu", IndexType.GreekLower, false, 1, 0);
Expression KINV = Tensors.parseExpression("KINV_\\alpha^\\beta=d_\\alpha^\\beta+(2*\\gamma+Power[\\gamma,2])*n_\\alpha*n^\\beta");
Expression K = Tensors.parseExpression("K^{\\mu\\nu\\gamma\\delta}_\\alpha^{\\beta}="
+ "d_\\alpha^\\beta*1/3*(g^{\\mu\\nu}*g^{\\gamma\\delta}+ g^{\\mu\\gamma}*g^{\\nu\\delta}+ g^{\\mu\\delta}*g^{\\nu\\gamma})"
+ "+1/12*(-2*\\lambda+Power[\\lambda,2])*("
+ "g^{\\mu\\nu}*d_\\alpha^\\gamma*g^{\\beta\\delta}"
+ "+g^{\\mu\\nu}*d_\\alpha^\\delta*g^{\\beta\\gamma}"
+ "+g^{\\mu\\gamma}*d_\\alpha^\\nu*g^{\\beta\\delta}"
+ "+g^{\\mu\\gamma}*d_\\alpha^\\delta*g^{\\beta\\nu}"
+ "+g^{\\mu\\delta}*d_\\alpha^\\nu*g^{\\beta\\gamma}"
+ "+g^{\\mu\\delta}*d_\\alpha^\\gamma*g^{\\beta\\nu}"
+ "+g^{\\nu\\gamma}*d_\\alpha^\\mu*g^{\\beta\\delta}"
+ "+g^{\\nu\\gamma}*d_\\alpha^\\delta*g^{\\beta\\mu}"
+ "+g^{\\nu\\delta}*d_\\alpha^\\mu*g^{\\beta\\gamma}"
+ "+g^{\\nu\\delta}*d_\\alpha^\\gamma*g^{\\beta\\mu}"
+ "+g^{\\gamma\\delta}*d_\\alpha^\\mu*g^{\\beta\\nu}"
+ "+g^{\\gamma\\delta}*d_\\alpha^\\nu*g^{\\beta\\mu})");
Expression S = Tensors.parseExpression("S^\\mu\\nu\\rho\\alpha\\beta=0");
//W^{\\mu \\nu }_{\\alpha }^{\\beta } = d^{\\nu }_{\\alpha }*R^{\\beta \\mu }+d^{\\mu }_{\\alpha }*R^{\\beta \\nu }+g^{\\mu \\beta }*R_{\\alpha }^{\\nu }+2*P_{\\alpha }^{\\beta }*g^{\\mu \\nu }+-2/3*d_{\\alpha }^{\\beta }*R^{\\mu \\nu }
Expression W = Tensors.parseExpression("W^{\\mu\\nu}_\\alpha^\\beta="
+ "2*P_{\\alpha}^{\\beta}*g^{\\mu\\nu}-2/3*R^\\mu\\nu*d_\\alpha^\\beta"
+ "-\\lambda/2*P_\\alpha^\\mu*g^\\nu\\beta"
+ "-\\lambda/2*P_\\alpha^\\nu*g^\\mu\\beta"
+ "-\\lambda/2*P^\\beta\\mu*d^\\nu_\\alpha"
+ "-\\lambda/2*P^\\beta\\nu*d^\\mu_\\alpha"
+ "+1/6*(\\lambda-2*Power[\\lambda,2])*("
+ "R_\\alpha^\\mu*g^\\nu\\beta"
+ "+R_\\alpha^\\nu*g^\\mu\\beta"
+ "+R^\\beta\\mu*d^\\nu_\\alpha"
+ "+R^\\beta\\nu*d^\\mu_\\alpha)"
+ "+1/6*(2*\\lambda-Power[\\lambda,2])*"
+ "(R_\\alpha^\\mu\\beta\\nu+R_\\alpha^\\nu\\beta\\mu)"
+ "+1/2*(2*\\lambda-Power[\\lambda,2])*g^\\mu\\nu*R_\\alpha^\\beta");
Expression N = Tensors.parseExpression("N^\\rho\\alpha\\beta=0");
Expression M = Tensors.parseExpression("M_\\alpha^\\beta = "
+ "P_\\alpha\\mu*P^\\mu\\beta-1/2*R_\\mu\\nu\\gamma\\alpha*R^\\mu\\nu\\gamma\\beta"
+ "+\\lambda/2*P_\\alpha\\mu*R^\\mu\\beta"
+ "+\\lambda/2*P_\\mu\\nu*R^\\mu_\\alpha^\\nu\\beta"
+ "+1/6*(\\lambda-2*Power[\\lambda,2])*R_\\alpha\\mu*R^\\mu\\beta"
+ "+1/12*(4*\\lambda+7*Power[\\lambda,2])*R_\\mu\\alpha\\nu^\\beta*R^\\mu\\nu"
+ "+1/4*(2*\\lambda-Power[\\lambda,2])*R_\\alpha\\mu\\nu\\gamma*R^\\gamma\\mu\\nu\\beta");
Expression F = Tensors.parseExpression("F_\\mu\\nu\\alpha\\beta=R_\\mu\\nu\\alpha\\beta");
Expression lambda = Tensors.parseExpression("\\lambda=gamma/(1+gamma)");
Expression gamma = Tensors.parseExpression("\\gamma=gamma");
KINV = (Expression) gamma.transform(lambda.transform(KINV));
K = (Expression) gamma.transform(lambda.transform(K));
S = (Expression) gamma.transform(lambda.transform(S));
W = (Expression) gamma.transform(lambda.transform(W));
M = (Expression) gamma.transform(lambda.transform(M));
OneLoopInput input = new OneLoopInput(4, KINV, K, S, W, N, M, F);
OneLoopCounterterms action = OneLoopCounterterms.calculateOneLoopCounterterms(input);
}
/**
* 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:
*
* 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})
*
*/
public static void testGravityGhosts() {
CC.setDefaultOutputFormat(OutputFormat.RedberryConsole);
Tensors.addSymmetry("P_\\mu\\nu", IndexType.GreekLower, false, 1, 0);
Expression KINV = Tensors.parseExpression("KINV_\\alpha^\\beta=d_\\alpha^\\beta+gamma*n_\\alpha*n^\\beta");
Expression K = Tensors.parseExpression("K^{\\mu\\nu}_\\alpha^{\\beta}=d_\\alpha^\\beta*g^\\mu\\nu-1/2*beta*(d_\\alpha^\\mu*g^\\nu\\beta+d_\\alpha^\\nu*g^\\mu\\beta)");
Expression S = Tensors.parseExpression("S^\\rho^\\mu_\\nu=0");
Expression W = Tensors.parseExpression("W^{\\alpha}_{\\beta}=(1+beta/2)*R^\\alpha_\\beta");
Expression F = Tensors.parseExpression("F_\\mu\\nu\\alpha\\beta=R_\\mu\\nu\\alpha\\beta");
Expression beta = Tensors.parseExpression("beta=gamma/(1+gamma)");
KINV = (Expression) beta.transform(KINV);
K = (Expression) beta.transform(K);
S = (Expression) beta.transform(S);
W = (Expression) beta.transform(W);
OneLoopInput input = new OneLoopInput(2, KINV, K, S, W, null, null, F);
OneLoopCounterterms action = OneLoopCounterterms.calculateOneLoopCounterterms(input);
}
/**
* This method calculates the main contribution to the one-loop counterterms
* of the gravitational field in the non-minimal gauge. The gauge fixing
* term in LaTeX notation:
*
* 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})
*
*/
public static void testLambdaGaugeGravity() {
CC.setDefaultOutputFormat(OutputFormat.RedberryConsole);
Expression KINV = Tensors.parseExpression("KINV_\\alpha\\beta^\\gamma\\delta = "
+ "(d_\\alpha^\\gamma*d_\\beta^\\delta+d_\\beta^\\gamma*d_\\alpha^\\delta)/2+"
+ "la/2*("
+ "d_\\alpha^\\gamma*n_\\beta*n^\\delta"
+ "+d_\\alpha^\\delta*n_\\beta*n^\\gamma"
+ "+d_\\beta^\\gamma*n_\\alpha*n^\\delta"
+ "+d_\\beta^\\delta*n_\\alpha*n^\\gamma)"
+ "-la*g^\\gamma\\delta*n_\\alpha*n_\\beta");
Expression K = Tensors.parseExpression("K^\\mu\\nu_\\alpha\\beta^\\gamma\\delta = "
+ "g^\\mu\\nu*(d_\\alpha^\\gamma*d_\\beta^\\delta+d_\\beta^\\gamma*d_\\alpha^\\delta)/2"
+ "-la/(4*(1+la))*("
+ "d_\\alpha^\\gamma*d_\\beta^\\mu*g^\\delta\\nu"
+ "+d_\\alpha^\\gamma*d_\\beta^\\nu*g^\\delta\\mu"
+ "+d_\\alpha^\\delta*d_\\beta^\\mu*g^\\gamma\\nu"
+ "+d_\\alpha^\\delta*d_\\beta^\\nu*g^\\gamma\\mu"
+ "+d_\\beta^\\gamma*d_\\alpha^\\mu*g^\\delta\\nu"
+ "+d_\\beta^\\gamma*d_\\alpha^\\nu*g^\\delta\\mu"
+ "+d_\\beta^\\delta*d_\\alpha^\\mu*g^\\gamma\\nu"
+ "+d_\\beta^\\delta*d_\\alpha^\\nu*g^\\gamma\\mu)"
+ "+la/(2*(1+la))*g^\\gamma\\delta*(d_\\alpha^\\mu*d_\\beta^\\nu+d_\\alpha^\\nu*d_\\beta^\\mu)");
Expression S = Tensors.parseExpression("S^\\rho_{\\alpha\\beta}^{\\gamma\\delta}=0");
Expression W = Tensors.parseExpression("W_{\\alpha\\beta}^{\\gamma\\delta}=P_\\alpha\\beta^\\gamma\\delta"
+ "-la/(2*(1+la))*(R_\\alpha^\\gamma_\\beta^\\delta+R_\\alpha^\\delta_\\beta^\\gamma)"
+ "+la/(4*(1+la))*("
+ "d_\\alpha^\\gamma*R_\\beta^\\delta"
+ "+d_\\alpha^\\delta*R_\\beta^\\gamma"
+ "+d_\\beta^\\gamma*R_\\alpha^\\delta"
+ "+d_\\beta^\\delta*R_\\alpha^\\gamma)");
Expression P = Tensors.parseExpression("P_\\gamma\\delta^\\mu\\nu = "
+ "R_\\gamma^\\mu_\\delta^\\nu+R_\\gamma^\\nu_\\delta^\\mu"
+ "+1/2*("
+ "d_\\gamma^\\mu*R_\\delta^\\nu"
+ "+d_\\gamma^\\nu*R_\\delta^\\mu"
+ "+d_\\delta^\\mu*R_\\gamma^\\nu"
+ "+d_\\delta^\\nu*R_\\gamma^\\mu)"
+ "-g^\\mu\\nu*R_\\gamma\\delta"
+ "-R^\\mu\\nu*g_\\gamma\\delta"
+ "+(-d_\\gamma^\\mu*d_\\delta^\\nu-d_\\gamma^\\nu*d_\\delta^\\mu+g^\\mu\\nu*g_\\gamma\\delta)*R/2");
W = (Expression) P.transform(W);
Expression F = Tensors.parseExpression("F_\\mu\\nu^\\lambda\\delta_\\rho\\tau = "
+ "R^\\lambda_\\rho\\mu\\nu*d^\\delta_\\tau+R^\\delta_\\tau\\mu\\nu*d^\\lambda_\\rho");
OneLoopInput input = new OneLoopInput(2, KINV, K, S, W, null, null, 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
CC.setDefaultOutputFormat(OutputFormat.RedberryConsole);
Expression KINV = Tensors.parseExpression("KINV_\\alpha^\\beta=d_\\alpha^\\beta");
Expression K = Tensors.parseExpression("K^\\mu\\nu_\\alpha^\\beta=d_\\alpha^\\beta*g^{\\mu\\nu}");
Expression S = Tensors.parseExpression("S^\\mu\\alpha\\beta=0");
Expression W = Tensors.parseExpression("W_\\alpha^\\beta=W_\\alpha^\\beta");
Expression F = Tensors.parseExpression("F_\\mu\\nu\\alpha\\beta=F_\\mu\\nu\\alpha\\beta");
OneLoopInput input = new OneLoopInput(2, KINV, 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
CC.setDefaultOutputFormat(OutputFormat.RedberryConsole);
//Phys. Rep. 119 ( 1985) 1-74
Expression KINV = Tensors.parseExpression("KINV_\\alpha^\\beta=d_\\alpha^\\beta");
Expression K = Tensors.parseExpression("K^\\mu\\nu_\\alpha^\\beta=d_\\alpha^\\beta*g^{\\mu\\nu}");
Expression S = Tensors.parseExpression("S^\\mu\\alpha\\beta=0");
//here P^... from BV equal to W^...
Expression W = Tensors.parseExpression("W_\\alpha^\\beta=W_\\alpha^\\beta-1/6*R*d_\\alpha^\\beta");
Expression F = Tensors.parseExpression("F_\\mu\\nu\\alpha\\beta=F_\\mu\\nu\\alpha\\beta");
OneLoopInput input = new OneLoopInput(2, KINV, K, S, W, null, null, F);
OneLoopCounterterms action = OneLoopCounterterms.calculateOneLoopCounterterms(input);
}
/**
* This method calculates one-loop counterterms of the fourth order minimal
* operator.
*/
public static void testMinimalFourthOrderOperator() {
//TIME = 6.2 s
CC.setDefaultOutputFormat(OutputFormat.RedberryConsole);
Tensors.addSymmetry("P_\\mu\\nu", IndexType.GreekLower, false, 1, 0);
Expression KINV = Tensors.parseExpression("KINV_\\alpha^\\beta=d_\\alpha^\\beta");
Expression K = Tensors.parseExpression("K^{\\mu\\nu\\gamma\\delta}_\\alpha^{\\beta}="
+ "d_\\alpha^\\beta*1/3*(g^{\\mu\\nu}*g^{\\gamma\\delta}+ g^{\\mu\\gamma}*g^{\\nu\\delta}+ g^{\\mu\\delta}*g^{\\nu\\gamma})");
Expression S = Tensors.parseExpression("S^\\mu\\nu\\rho\\alpha\\beta=0");
Expression W = Tensors.parseExpression("W^{\\mu\\nu}_\\alpha^\\beta=0*W^{\\mu\\nu}_\\alpha^\\beta");
Expression N = Tensors.parseExpression("N^\\rho\\alpha\\beta=0*N^\\rho\\alpha\\beta");
Expression M = Tensors.parseExpression("M_\\alpha^\\beta = 0*M_\\alpha^\\beta");
Expression F = Tensors.parseExpression("F_\\mu\\nu\\alpha\\beta=F_\\mu\\nu\\alpha\\beta");
OneLoopInput input = new OneLoopInput(4, KINV, K, S, W, N, M, F);
OneLoopCounterterms action = OneLoopCounterterms.calculateOneLoopCounterterms(input);
}
/**
* This method calculates ghosts contribution to the one-loop counterterms
* of the theory with spin = 3.
*/
public static void testSpin3Ghosts() {
//TIME = 990 s
CC.setDefaultOutputFormat(OutputFormat.RedberryConsole);
Expression KINV = Tensors.parseExpression(
"KINV^{\\alpha\\beta}_{\\mu\\nu} = P^{\\alpha\\beta}_{\\mu\\nu}-1/4*c*g_{\\mu\\nu}*g^{\\alpha\\beta}+"
+ "(1/4)*b*(n_{\\mu}*n^{\\alpha}*d^{\\beta}_{\\nu}+n_{\\mu}*n^{\\beta}*d^{\\alpha}_{\\nu}+n_{\\nu}*n^{\\alpha}*d^{\\beta}_{\\mu}+n_{\\nu}*n^{\\beta}*d^{\\alpha}_{\\mu})+"
+ "c*(n_{\\mu}*n_{\\nu}*g^{\\alpha\\beta}+n^{\\alpha}*n^{\\beta}*g_{\\mu\\nu})"
+ "-c*b*n_{\\mu}*n_{\\nu}*n^{\\alpha}*n^{\\beta}");
Expression K = Tensors.parseExpression(
"K^{\\mu\\nu}^{\\alpha\\beta}_{\\gamma\\delta} = g^{\\mu\\nu}*P^{\\alpha\\beta}_{\\gamma\\delta}+"
+ "(1+2*beta)*((1/4)*(d^{\\mu}_{\\gamma}*g^{\\alpha \\nu}*d^{\\beta}_{\\delta} + d^{\\mu}_{\\delta}*g^{\\alpha \\nu}*d^{\\beta}_{\\gamma}+d^{\\mu}_{\\gamma}*g^{\\beta \\nu}*d^{\\alpha}_{\\delta}+ d^{\\mu}_{\\delta}*g^{\\beta \\nu}*d^{\\alpha}_{\\gamma})+"
+ "(1/4)*(d^{\\nu}_{\\gamma}*g^{\\alpha \\mu}*d^{\\beta}_{\\delta} + d^{\\nu}_{\\delta}*g^{\\alpha \\mu}*d^{\\beta}_{\\gamma}+d^{\\nu}_{\\gamma}*g^{\\beta \\mu}*d^{\\alpha}_{\\delta}+ d^{\\nu}_{\\delta}*g^{\\beta \\mu}*d^{\\alpha}_{\\gamma}) -"
+ "(1/4)*(g_{\\gamma\\delta}*g^{\\mu \\alpha}*g^{\\nu \\beta}+g_{\\gamma\\delta}*g^{\\mu \\beta}*g^{\\nu \\alpha})-"
+ "(1/4)*(g^{\\alpha\\beta}*d^{\\mu}_{\\gamma}*d^{\\nu}_{\\delta}+g^{\\alpha\\beta}*d^{\\mu}_{\\delta}*d^{\\nu}_{\\gamma})+(1/8)*g^{\\mu\\nu}*g_{\\gamma\\delta}*g^{\\alpha\\beta})");
Expression P = Tensors.parseExpression(
"P^{\\alpha\\beta}_{\\mu\\nu} = (1/2)*(d^{\\alpha}_{\\mu}*d^{\\beta}_{\\nu}+d^{\\alpha}_{\\nu}*d^{\\beta}_{\\mu})-(1/4)*g_{\\mu\\nu}*g^{\\alpha\\beta}");
KINV = (Expression) P.transform(KINV);
K = (Expression) P.transform(K);
Expression consts[] = {
Tensors.parseExpression("c=(1+2*beta)/(5+6*beta)"),
Tensors.parseExpression("b=-(1+2*beta)/(1+beta)")
};
for (Expression cons : consts) {
KINV = (Expression) cons.transform(KINV);
K = (Expression) cons.transform(K);
}
Expression S = (Expression) Tensors.parse("S^\\rho^{\\alpha\\beta}_{\\mu\\nu}=0");
Expression W = (Expression) Tensors.parse("W^{\\alpha\\beta}_{\\mu\\nu}=0");
Expression F = Tensors.parseExpression("F_\\mu\\nu\\alpha\\beta\\gamma\\delta=0");
Transformation[] ds = OneLoopUtils.antiDeSitterBackground();
Transformation[] tr = new Transformation[ds.length + 1];
System.arraycopy(ds, 0, tr, 0, ds.length);
tr[tr.length - 1] = FactorTransformation.FACTOR;
OneLoopInput input = new OneLoopInput(2, KINV, K, S, W, null, null, F, tr);
OneLoopCounterterms action = OneLoopCounterterms.calculateOneLoopCounterterms(input);
}
/**
* This method calculates the main contribution to the one-loop counterterms
* of the gravitational field in general the non-minimal gauge. The gauge
* fixing term in LaTeX notation:
*
* 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+\beta)/2 g^{\alpha\beta} \nabla^\mu h_{\alpha\beta})
*
*/
public static void testNonMinimalGaugeGravity() {
//FIXME works more than hour
CC.setDefaultOutputFormat(OutputFormat.RedberryConsole);
Tensors.addSymmetry("R_\\mu\\nu", IndexType.GreekLower, false, new int[]{1, 0});
Tensors.addSymmetry("R_\\mu\\nu\\alpha\\beta", IndexType.GreekLower, true, new int[]{0, 1, 3, 2});
Tensors.addSymmetry("R_\\mu\\nu\\alpha\\beta", IndexType.GreekLower, false, new int[]{2, 3, 0, 1});
Expression KINV = Tensors.parseExpression("KINV_\\alpha\\beta^\\gamma\\delta = "
+ "(d_\\alpha^\\gamma*d_\\beta^\\delta+d_\\beta^\\gamma*d_\\alpha^\\delta)/2-"
+ "la/2*("
+ "d_\\alpha^\\gamma*n_\\beta*n^\\delta"
+ "+d_\\alpha^\\delta*n_\\beta*n^\\gamma"
+ "+d_\\beta^\\gamma*n_\\alpha*n^\\delta"
+ "+d_\\beta^\\delta*n_\\alpha*n^\\gamma)"
+ "-ga*(g_\\alpha\\beta*n^\\gamma*n^\\delta+g^\\gamma\\delta*n_\\alpha*n_\\beta)"
+ "-1/2*g_\\alpha\\beta*g^\\gamma\\delta"
+ "+2*ga*(ga*la-2*ga+2*la)*n_\\alpha*n_\\beta*n^\\gamma*n^\\delta");
Expression K = Tensors.parseExpression("K^\\mu\\nu_\\alpha\\beta^\\gamma\\delta = "
+ "g^\\mu\\nu*(d_\\alpha^\\gamma*d_\\beta^\\delta+d_\\beta^\\gamma*d_\\alpha^\\delta)/2"
+ "-la/(4*(1+la))*("
+ "d_\\alpha^\\gamma*d_\\beta^\\mu*g^\\delta\\nu"
+ "+d_\\alpha^\\gamma*d_\\beta^\\nu*g^\\delta\\mu"
+ "+d_\\alpha^\\delta*d_\\beta^\\mu*g^\\gamma\\nu"
+ "+d_\\alpha^\\delta*d_\\beta^\\nu*g^\\gamma\\mu"
+ "+d_\\beta^\\gamma*d_\\alpha^\\mu*g^\\delta\\nu"
+ "+d_\\beta^\\gamma*d_\\alpha^\\nu*g^\\delta\\mu"
+ "+d_\\beta^\\delta*d_\\alpha^\\mu*g^\\gamma\\nu"
+ "+d_\\beta^\\delta*d_\\alpha^\\nu*g^\\gamma\\mu)"
+ "+(la-be)/(2*(1+la))*(g^\\gamma\\delta*(d_\\alpha^\\mu*d_\\beta^\\nu+d_\\alpha^\\nu*d_\\beta^\\mu)+g_\\alpha\\beta*(g^\\gamma\\mu*g^\\delta\\nu+g^\\gamma\\nu*g^\\delta\\mu))"
+ "+g^\\mu\\nu*g_\\alpha\\beta*g^\\gamma\\delta*(-1+(1+be)**2/(2*(1+la)))");
K = (Expression) Tensors.parseExpression("be = ga/(1+ga)").transform(K);
Expression S = Tensors.parseExpression("S^\\rho_{\\alpha\\beta}^{\\gamma\\delta}=0");
Expression W = Tensors.parseExpression("W_{\\alpha\\beta}^{\\gamma\\delta}=P_\\alpha\\beta^\\gamma\\delta"
+ "-la/(2*(1+la))*(R_\\alpha^\\gamma_\\beta^\\delta+R_\\alpha^\\delta_\\beta^\\gamma)"
+ "+la/(4*(1+la))*("
+ "d_\\alpha^\\gamma*R_\\beta^\\delta"
+ "+d_\\alpha^\\delta*R_\\beta^\\gamma"
+ "+d_\\beta^\\gamma*R_\\alpha^\\delta"
+ "+d_\\beta^\\delta*R_\\alpha^\\gamma)");
Expression P = Tensors.parseExpression("P_\\alpha\\beta^\\mu\\nu ="
+ "1/4*(d_\\alpha^\\gamma*d_\\beta^\\delta+d_\\alpha^\\delta*d_\\beta^\\gamma-g_\\alpha\\beta*g^\\gamma\\delta)"
+ "*(R_\\gamma^\\mu_\\delta^\\nu+R_\\gamma^\\nu_\\delta^\\mu-g^\\mu\\nu*R_\\gamma\\delta-g_\\gamma\\delta*R^\\mu\\nu"
+ "+1/2*(d^\\mu_\\gamma*R^\\nu_\\delta+d^\\nu_\\gamma*R_\\delta^\\mu+d^\\mu_\\delta*R^\\nu_\\gamma+d^\\nu_\\delta*R^\\mu_\\gamma)"
+ "-1/2*(d^\\mu_\\gamma*d^\\nu_\\delta+d^\\nu_\\gamma*d^\\mu_\\delta)*(R-2*LA)+1/2*g_\\gamma\\delta*g^\\mu\\nu*R)");
P = (Expression) ExpandTransformation.expand(P,
EliminateMetricsTransformation.ELIMINATE_METRICS,
Tensors.parseExpression("R_{\\mu \\nu}^{\\mu}_{\\alpha} = R_{\\nu\\alpha}"),
Tensors.parseExpression("R_{\\mu\\nu}^{\\alpha}_{\\alpha}=0"),
Tensors.parseExpression("R_{\\mu}^{\\mu}= R"));
W = (Expression) P.transform(W);
Expression F = Tensors.parseExpression("F_\\mu\\nu^\\lambda\\delta_\\rho\\tau = "
+ "R^\\lambda_\\rho\\mu\\nu*d^\\delta_\\tau+R^\\delta_\\tau\\mu\\nu*d^\\lambda_\\rho");
OneLoopInput input = new OneLoopInput(2, KINV, K, S, W, null, null, F);
OneLoopCounterterms action = OneLoopCounterterms.calculateOneLoopCounterterms(input);
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy