Symbolic Computation in Theoretical Physics with Python

Part 3: PyRate

PyRate

PyRate is a Python library for the computation of renormalization group equations for general, non-supersymmetric gauge theories.

Standard model

The Standard Model model-file:

from pathlib import Path
with Path.open(Path('models') / 'SM.model', 'rt') as model_file:
    print(model_file.read())

# YAML 1.1
---
Author: Lohan Sartore
Date: 08.06.2020
Name: SM
Groups: {U1Y: U1, SU2L: SU2, SU3c: SU3}


Fermions: {
    Q : {Gen: 3, Qnb: {U1Y: 1/6, SU2L: 2, SU3c: 3}},
    L : {Gen: 3, Qnb: {U1Y: -1/2, SU2L: 2}},
    uR : {Gen: 3, Qnb: {U1Y: 2/3, SU3c: 3}},
    dR : {Gen: 3, Qnb: {U1Y: -1/3, SU3c: 3}},
    eR : {Gen: 3, Qnb: {U1Y: -1}},
}

RealScalars: {
}

ComplexScalars: {
    H : {RealFields: [Pi, Sigma], Norm: 1/sqrt(2), Qnb: {U1Y: 1/2, SU2L: 2}},
}


Potential: {

    Definitions: {
        Htilde[i] : Eps[i,j]*Hbar[j]
    },

    Yukawas: {
        Yu : Qbar[i,a] Htilde[i] uR[a],
        Yd : Qbar[i,a] H[i] dR[a],
        Ye : Lbar[i] H[i] eR
    },

    QuarticTerms: {
        lambda : (Hbar[i] H[i])**2
    },

    ScalarMasses: {
        mu : -Hbar[i] H[i]
    }

}

Vevs: {
    v: Pi[2]
}

Substitutions: {
    # Rename the gauge coupling constants
    g_U1Y : g1,
    g_SU2L : g2,
    g_SU3c : g3,

    # Possibly define GUT normalizations
    g1 : sqrt(5/3) * g1,

    # Substitutions for Yukawa matrices
    Yu : [0, 0, 'yt'],
    Yd : [0, 0, 'yb'],
    Ye : [0, 0, 'ytau']
}

Latex: {
    # Particles

    uR : u_R,
    dR : d_R,
    eR : e_R,

    Pi : \Pi,
    Sigma : \Sigma,

    Htilde : \tilde{H},

    # Couplings

    g1 : g_1,
    g2 : g_2,
    g3 : g_3,

    Yu : Y_u,
    Yd : Y_d,
    Ye : Y_e,

    lambda : \lambda,
    mu : \mu,

    yt : y_t,
    yb : y_b,
    ytau: y_\tau
}

Run PyRate to compute the 2-loop RGEs of the Standard Model:

%run pyR@TE.py --no-MathematicaOutput -m models/SM.model -l 2

Solve the RGEs and plot the results:

import sys
sys.path.append('results/SM/PythonOutput')

from numpy import sqrt, pi
from SM import RGEsolver

# Create solver object
rge = RGEsolver('rge', tmin=1.9, tmax=20, initialScale=1.9)

# Running scheme
rge.loops = {'GaugeCouplings': 2,
             'Yukawas': 2,
             'QuarticTerms': 2,
             'ScalarMasses': 2,
             'Vevs': 2}

# Gauge Couplings
rge.g1.initialValue = sqrt(4*pi/128 / (1-.22)) * sqrt(5/3)
rge.g2.initialValue = sqrt(4*pi/128 / .22)
rge.g3.initialValue = sqrt(4*pi*.12)

# Yukawa Couplings
rge.yt.initialValue = .9
rge.yb.initialValue = .03
rge.ytau.initialValue = .01

# Quartic Couplings
rge.lambda_.initialValue = 0.13/2

# Scalar Mass Couplings
rge.mu.initialValue = sqrt(.13) * 246

# Vacuum-expectation values
rge.v.initialValue = 246

# Choose Landau gauge
rge.fixGauge(0)

# Solve the system of RGEs 
rge.solve(step = .05)

# Plot the results
rge.plot(figSize=(1100, 1000), subPlots=True, printLoopLevel=True)

System of RGEs solved in 0.011 seconds.

Show the generated PDF containing the model details:

from IPython.display import IFrame
IFrame("_pyrate/results/SM/SM.pdf", width=800, height=800)