物理の本

詳細pdf版

---

Peskin 1

Peskin 2

Peskin 3

Peskin 4

Peskin 5

Peskin 6

Peskin 7

Peskin 8

---

Peskin & Schroeder. An Introduction to Quantum Field Theory

非可換ゲージ理論の頂点などの縮約を計算する．作ってみたら意外と汎用性があった． もとのnotebookはこれ

非可換ゲージ理論の頂点計算．添字は全て下に付ける．

import sympy

縮約を計算する．入力は[coeff, momentum or metric, ...]のリスト

D = sympy.Symbol("D")

def calculate_contract(input):
    # input: [coeff, momentum or metric, ...]
    coeff = input.pop(0)

    # get metrics and momentums from input
    metrics = []
    momentums = []
    for i in input:
        if i[0:1] == 'g':
            str = i[4:-1]
            first_index_abr = str.split('\\')[0][0]
            second_index_abr = str.split('\\')[1][0]
            metrics.append('g_' + first_index_abr + second_index_abr)
        else:
            momentums.append(i[0:2] + i[3])
    input_abr = [coeff] + metrics + momentums

    # define dict of metrics {'original_key': [current index, current index], ...}
    metrics_dict = {}
    for i in metrics:
        metrics_dict[i] = [i.split('_')[1][0], i.split('_')[1][1]]

    # define dict of momentums {'original_key': [label, current index], ...}
    momentums_dict = {}
    for i in momentums:
        momentums_dict[i] = i.split('_')

    # get indices of metrics
    metrics_indices = []
    for i in range(len(metrics)):
        metrics_indices.append(metrics[i].split('_')[1][0])
        metrics_indices.append(metrics[i].split('_')[1][1])

    # get indices of momentums
    momentums_indices = []
    for i in range(len(momentums)):
        momentums_indices.append(momentums[i].split('_')[1])

    # find true and dummy indices
    all_indices = metrics_indices + momentums_indices
    summing_indices = []
    tensor_indices = []
    for i in all_indices:
        if all_indices.count(i) == 2:
            summing_indices.append(i)
        elif all_indices.count(i) >= 2:
            print(i, 'too many !')
        else:
            tensor_indices.append(i)
    summing_indices = list(set(summing_indices))

    # sum over dummy indices
    for i in summing_indices:
        if metrics_indices.count(i) == 1:
            # vector and metric
            metric_at = int(metrics_indices.index(i) / 2)
            momentum_at = momentums_indices.index(i)
            contracting_metric = metrics[metric_at]
            contracting_momentum = momentums[momentum_at]
            another_index = metrics_dict[contracting_metric]
            another_index.remove(i)
            metrics_dict[contracting_metric] = []
            metrics_indices[2*metric_at] = ''
            metrics_indices[2*metric_at + 1] = ''
            momentums_dict[contracting_momentum] = [contracting_momentum[0], another_index[0]]
            momentums_indices[momentum_at] = another_index[0]
            # print(str('\u03A3' + i + ':'), contracting_metric, contracting_momentum, '->', str(contracting_momentum[0]+ '_'+ another_index[0]))
        elif metrics_indices.count(i) == 2:
            # metric and metric
            metrics_loc = [j for j, x in enumerate(metrics_indices) if x == i]
            first_metric_at = int(metrics_loc[0] / 2)
            second_metric_at = int(metrics_loc[1] / 2)
            first_contracting_metric = metrics[first_metric_at]
            second_contracting_metric = metrics[second_metric_at]
            if first_metric_at == second_metric_at: # g_ss = D
                metrics_dict[first_contracting_metric] = [D]
                # print(str('\u03A3' + i + ':'), metrics[first_metric_at], '-> D')
                metrics_indices[2*first_metric_at] = ''
                metrics_indices[2*first_metric_at + 1] = ''
            else:
                first_another_index = metrics_dict[first_contracting_metric]
                first_another_index.remove(i)
                second_another_index = metrics_dict[second_contracting_metric]
                second_another_index.remove(i)
                metrics_dict[first_contracting_metric] = [first_another_index[0], second_another_index[0]]
                metrics_indices[2*first_metric_at] = first_another_index[0]
                metrics_indices[2*first_metric_at + 1] = second_another_index[0]
                metrics_dict[second_contracting_metric] = []
                metrics_indices[2*second_metric_at] = ''
                metrics_indices[2*second_metric_at + 1] = ''
                # print(str('\u03A3' + i + ':'), metrics[first_metric_at], metrics[second_metric_at], '->', str('g_' + first_another_index[0] + second_another_index[0]))
        else:
            # vector and vector
            momentums_loc = [j for j, x in enumerate(momentums_indices) if x == i]
            first_momentum_at = momentums_loc[0]
            second_momentum_at = momentums_loc[1]
            first_contracting_momentum = momentums[first_momentum_at]
            second_contracting_momentum = momentums[second_momentum_at]
            momentums_dict[first_contracting_momentum] = [momentums_dict[first_contracting_momentum][0] + momentums_dict[second_contracting_momentum][0], '']
            momentums_dict[second_contracting_momentum] = []

    # concatenate dictinoaries
    output = [coeff]
    for i in metrics_dict.values():
        if i == [D]:
            output.append('D')
        elif i != []:
            output.append('g_' + i[0] + i[1])
    for i in momentums_dict.values():
        if i != []:
            if i[1] == '':
                output.append(i[0])
            else:
                output.append(i[0] + '_' + i[1])

    # print(' '.join(input_abr) , '=', ' '.join(output))
    return output

運動量文字とLorentz添字から4運動量の成分を返す： $$ k, \mu \to k_\mu . $$

def mo(momentum, index_abr):
    if momentum != 0:
        terms = list(sympy.Add.make_args(momentum))
        momentum_indexed = 0
        for i in range(len(terms)):
            term_indexed = str(terms[i]) + '_' + index_abr
            term_indexed = sympy.sympify(term_indexed, globals())
            momentum_indexed += term_indexed
        return momentum_indexed
    else:
        return 0

運動量文字とLorentz添字から3-boson頂点を返す： $$ \mu, \nu, \rho, k, p, q \to g_{\mu\nu} (k-p)_\rho + g_{\nu\rho} (p-q)_\mu + g_{\rho\mu} (q-k)_\nu . $$

def three_vertex(m, n, r, k, p, q):
    if k+p+q != 0:
        print('momentum not conserved!')
    T1 = sympy.sympify('g_' + m + n, globals()) * (mo(k - p, r))
    T2 = sympy.sympify('g_' + n + r, globals()) * (mo(p - q, m))
    T3 = sympy.sympify('g_' + r + m, globals()) * (mo(q - k, n))
    T = T1 + T2 + T3
    return T

ゲージ群添字とLorentz添字から4-bosonを返す： $$ a, b, c, d, \mu, \nu, \rho, \sigma \to f^{abe} f^{cde} (g_{\mu\rho} g_{\nu\sigma} - g_{\mu\sigma} g_{\nu\rho}) + f^{ace} f^{bde} (g_{\mu\nu} g_{\rho\sigma} - g_{\mu\sigma} g_{\nu\rho}) + f^{ade} f^{bce} (g_{\mu\nu} g_{\rho\sigma} - g_{\mu\rho} g_{\nu\sigma}) . $$

def four_vertex(a, b, c, d, e, m, n, r, s):
    F1 = sympy.sympify('f_' + a + b + e, globals()) * sympy.sympify('f_' + c + d + e, globals()) * (sympy.sympify('g_' + m + r, globals()) * sympy.sympify('g_' + n + s, globals()) - sympy.sympify('g_' + m + s, globals()) * sympy.sympify('g_' + n + r, globals()))
    F2 = sympy.sympify('f_' + a + c + e, globals()) * sympy.sympify('f_' + b + d + e, globals()) * (sympy.sympify('g_' + m + n, globals()) * sympy.sympify('g_' + r + s, globals()) - sympy.sympify('g_' + m + s, globals()) * sympy.sympify('g_' + n + r, globals()))
    F3 = sympy.sympify('f_' + a + d + e, globals()) * sympy.sympify('f_' + b + c + e, globals()) * (sympy.sympify('g_' + m + n, globals()) * sympy.sympify('g_' + r + s, globals()) - sympy.sympify('g_' + m + r, globals()) * sympy.sympify('g_' + n + s, globals()))
    F = F1 + F2 + F3
    return F

運動量文字，Lorentz添字，ゲージ群の添字を定義

momentum_chars = ['k', 'p', 'q', 'K', 'l']
Lorentz_indices = ['mu', 'nu', 'rho', 'sigma', 'lambda', 'kappa', 'tau', 'xi', 'eta']
gruoup_indices = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']

Lorentz添字を1文字目で表す(m=$\mu$)

Lorentz_indices_abr = [s[0] for s in Lorentz_indices]

運動量文字のsymbolを定義する

for i in momentum_chars:
    exec(i + ' = sympy.symbols(\'' + i + '\')')

計量成分のsymbolを定義する(g_mn=$g_{\mu\nu}$)．1文字目の添字の順番≤2文字目の添字の順番とする．

for i in range(len(Lorentz_indices)):
    for j in range(i, len(Lorentz_indices)):
        exec('g_' + Lorentz_indices_abr[i] + Lorentz_indices_abr[j] + '= sympy.symbols(\'g_{\\\\' + Lorentz_indices[i] + '\\\\' + Lorentz_indices[j] + '}\')')
        exec('g_' + Lorentz_indices_abr[j] + Lorentz_indices_abr[i] + '= sympy.symbols(\'g_{\\\\' + Lorentz_indices[i] + '\\\\' + Lorentz_indices[j] + '}\')')

運動量成分のsymbolを定義する(k_m=$k_\mu$)

for i in range(len(momentum_chars)):
    for j in range(len(Lorentz_indices)):
        exec(momentum_chars[i] + '_' + Lorentz_indices_abr[j] + '= sympy.symbols(\'' + momentum_chars[i] + '_\\\\' + Lorentz_indices[j] + '\')')

運動量の内積を定義する(kp=$kp$)．1文字目の運動量の順番≤2文字目の運動量の順番

for i in range(len(momentum_chars)):
    for j in range(i, len(momentum_chars)):
        exec(momentum_chars[i] + momentum_chars[j] + '= sympy.symbols(\'(' + momentum_chars[i] + momentum_chars[j] + ')\')')
        exec(momentum_chars[j] + momentum_chars[i] + '= sympy.symbols(\'(' + momentum_chars[i] + momentum_chars[j] + ')\')')

ゲージ群の構造定数を定義する(f_abc=$f^{abc}$)

for a in range(len(gruoup_indices)):
    for b in range(len(gruoup_indices)):
        for c in range(len(gruoup_indices)):
            exec('f_' + gruoup_indices[a] + gruoup_indices[b] + gruoup_indices[c] + '= sympy.symbols(\'f_' + gruoup_indices[a] + gruoup_indices[b] + gruoup_indices[c] + '\')')

頂点の積を計算する．入力はsympyのequation

def calculate_vertices(eq):
    eq = sympy.expand(eq)
    terms = list(sympy.Add.make_args(eq))
    for i in range(len(terms)):
        terms[i] = sympy.simplify(terms[i])
    terms_cal = []
    for i in range(len(terms)):
        term = str(terms[i])
        if term[0] == '-':
            if term[1].isdigit() == False:
                term = term.replace('-', '-1*')
        elif term[0].isdigit() == False:
            term = '1*' + term
        while '**2' in term:
            end = term.find('**2')
            start = term.rfind('*', 0, end)
            term = term[:end+1] + term[start+1:end] + term[end+3:]
        term = term.split('*')
        if len(term) != len(set(term)):
            dups = [j for j in set(term) if term.count(j) > 1]
            for j in dups:
                term.remove(j)
                term.remove(j)
                if j[0] in momentum_chars:
                    # [..., k_m, k_m, ...] -> [kk..., ...]
                    term[0] = term[0] + '*' + j[0] + j[0]
                elif j[0] == 'g':
                    # [..., g_mn, g_mn, ...] -> [D..., ...]
                    term[0] = 'D*' + term[0]
                else:
                    # [..., x, x, ...] -> [x**2..., ...]
                    term[0] = term[0] + '*' + j[0] +'*' + j[0]
        # Lorentz scalars in coeff
        for i in term[1:]:
            if i[0] not in momentum_chars and i[0] != 'g':
                term.remove(i)
                term[0] = term[0] + '*' + i
        term_cal = calculate_contract(term)
        term_cal = '*'.join(term_cal)
        terms_cal.append(term_cal)

    eq_cal = 0
    for i in terms_cal:
        eq_cal += sympy.sympify(i, globals())
    eq_cal = sympy.simplify(eq_cal)
    # print(sympy.latex(eq_cal))
    return eq_cal

Problem 16.3

3-boson頂点($AAA + AAA + AAA$)

t1 = g_ms*(2*p_k - k_k) + g_sk*(- p_m + 2*k_m) + g_km*(-k_s - p_s)
t2 = g_sn*(2*p_l - k_l) + g_nl*(- p_s - k_s) + g_ls*(2*k_n - p_n)
t3 = 2*g_kl*k_r - g_lr*k_k - g_rk*k_l

expr = calculate_vertices(t1*t2*t3)
display(expr.subs(D, 4))

$\displaystyle 2 (kk) g_{\mu\nu} k_{\rho} + 4 (kk) g_{\mu\nu} p_{\rho} + 2 (kk) g_{\mu\rho} k_{\nu} - 3 (kk) g_{\mu\rho} p_{\nu} + 2 (kk) g_{\nu\rho} k_{\mu} - 3 (kk) g_{\nu\rho} p_{\mu} - 8 (kp) g_{\mu\nu} p_{\rho} - 2 (kp) g_{\mu\rho} k_{\nu} + 3 (kp) g_{\mu\rho} p_{\nu} - 2 (kp) g_{\nu\rho} k_{\mu} + 3 (kp) g_{\nu\rho} p_{\mu} + 10 (pp) g_{\mu\nu} k_{\rho} - (pp) g_{\mu\rho} k_{\nu} - (pp) g_{\nu\rho} k_{\mu} + 18 k_{\mu} k_{\nu} k_{\rho} - 9 k_{\mu} k_{\rho} p_{\nu} + 3 k_{\mu} p_{\nu} p_{\rho} - 9 k_{\nu} k_{\rho} p_{\mu} + 3 k_{\nu} p_{\mu} p_{\rho} - 6 k_{\rho} p_{\mu} p_{\nu}$

4-boson頂点($AAAA + AAAA$)

t1 = four_vertex('a', 'b', 'e', 'f', 'g', 'm', 'n', 'l', 'k')
t2 = four_vertex('e', 'f', 'c', 'd', 'h', 'l', 'k', 'r', 's')

expr = calculate_vertices(t1*t2)
display(expr.subs(D, 4))

$\displaystyle 2 f_{abg} f_{cdh} f_{efg} f_{efh} g_{\mu\rho} g_{\nu\sigma} - 2 f_{abg} f_{cdh} f_{efg} f_{efh} g_{\mu\sigma} g_{\nu\rho} + f_{abg} f_{ech} f_{efg} f_{fdh} g_{\mu\rho} g_{\nu\sigma} - f_{abg} f_{ech} f_{efg} f_{fdh} g_{\mu\sigma} g_{\nu\rho} - f_{abg} f_{edh} f_{efg} f_{fch} g_{\mu\rho} g_{\nu\sigma} + f_{abg} f_{edh} f_{efg} f_{fch} g_{\mu\sigma} g_{\nu\rho} + f_{aeg} f_{bfg} f_{cdh} f_{efh} g_{\mu\rho} g_{\nu\sigma} - f_{aeg} f_{bfg} f_{cdh} f_{efh} g_{\mu\sigma} g_{\nu\rho} + 2 f_{aeg} f_{bfg} f_{ech} f_{fdh} g_{\mu\nu} g_{\rho\sigma} + f_{aeg} f_{bfg} f_{ech} f_{fdh} g_{\mu\rho} g_{\nu\sigma} + 2 f_{aeg} f_{bfg} f_{edh} f_{fch} g_{\mu\nu} g_{\rho\sigma} + f_{aeg} f_{bfg} f_{edh} f_{fch} g_{\mu\sigma} g_{\nu\rho} - f_{afg} f_{beg} f_{cdh} f_{efh} g_{\mu\rho} g_{\nu\sigma} + f_{afg} f_{beg} f_{cdh} f_{efh} g_{\mu\sigma} g_{\nu\rho} + 2 f_{afg} f_{beg} f_{ech} f_{fdh} g_{\mu\nu} g_{\rho\sigma} + f_{afg} f_{beg} f_{ech} f_{fdh} g_{\mu\sigma} g_{\nu\rho} + 2 f_{afg} f_{beg} f_{edh} f_{fch} g_{\mu\nu} g_{\rho\sigma} + f_{afg} f_{beg} f_{edh} f_{fch} g_{\mu\rho} g_{\nu\sigma}$

3, 4-boson頂点($AAAA + AAA + AAA$)

t1 = four_vertex('e', 'f', 'c', 'd', 'h', 'l', 'k', 'r', 's')
t2 = three_vertex('m', 'l', 't', 0, -k, k)
t3 = three_vertex('n', 't', 'k', 0, -k, k)
"""
t2*t3 =
(kk) g_{\mu\lambda} g_{\nu\kappa} + 4 g_{\kappa\lambda} k_{\mu} k_{\nu} - 2 g_{\mu\kappa} k_{\lambda} k_{\nu} - g_{\mu\lambda} k_{\kappa} k_{\nu} + g_{\mu\nu} k_{\kappa} k_{\lambda} - g_{\nu\kappa} k_{\lambda} k_{\mu} - 2 g_{\nu\lambda} k_{\kappa} k_{\mu}
"""
t23 = 5*g_mn*g_lk + 2*g_ml*g_nk - 4*g_mk*g_nl

expr = calculate_vertices(t1*t23)
display(expr.subs(D, 4))

$\displaystyle 6 f_{cdh} f_{efh} g_{\mu\rho} g_{\nu\sigma} - 6 f_{cdh} f_{efh} g_{\mu\sigma} g_{\nu\rho} + 13 f_{ech} f_{fdh} g_{\mu\nu} g_{\rho\sigma} + 4 f_{ech} f_{fdh} g_{\mu\rho} g_{\nu\sigma} - 2 f_{ech} f_{fdh} g_{\mu\sigma} g_{\nu\rho} + 13 f_{edh} f_{fch} g_{\mu\nu} g_{\rho\sigma} - 2 f_{edh} f_{fch} g_{\mu\rho} g_{\nu\sigma} + 4 f_{edh} f_{fch} g_{\mu\sigma} g_{\nu\rho}$

3, 4-boson頂点($AAA + AAA + AAA + AAAA$)

t1 = three_vertex('m', 'l', 'e', 0, -k, k)
t2 = three_vertex('l', 'r', 'k', k, 0, -k)
t3 = three_vertex('x', 'k', 's', -k, k, 0)
t4 = three_vertex('n', 'e', 'x', 0, -k, k)

expr = calculate_vertices(t1*t2*t3*t4)
display(expr.subs(D, 4))

$\displaystyle (kk)^{2} g_{\mu\nu} g_{\rho\sigma} + (kk)^{2} g_{\mu\rho} g_{\nu\sigma} + 3 (kk) g_{\mu\nu} k_{\rho} k_{\sigma} + 3 (kk) g_{\mu\rho} k_{\nu} k_{\sigma} + 3 (kk) g_{\nu\sigma} k_{\mu} k_{\rho} + 3 (kk) g_{\rho\sigma} k_{\mu} k_{\nu} + 34 k_{\mu} k_{\nu} k_{\rho} k_{\sigma}$

Problem 18.3

3-boson頂点($AAA + AAA + \mathcal{O}_g$)

t1 = three_vertex('n', 'r', 'l', -k, p, k-p)
t2 = three_vertex('n', 'l', 's', k, p-k, -p)

expr = calculate_vertices(t1*t2)
display(expr.subs(D, 4))

$\displaystyle 2 (kk) g_{\rho\sigma} - 2 (kp) g_{\rho\sigma} + 5 (pp) g_{\rho\sigma} + 10 k_{\rho} k_{\sigma} - 5 k_{\rho} p_{\sigma} - 5 k_{\sigma} p_{\rho} - 2 p_{\rho} p_{\sigma}$

t1 = three_vertex('x', 'r', 'l', -k, p, k-p)
t2 = three_vertex('t', 'l', 's', k, p-k, -p)

expr = calculate_vertices(t1*t2)

t3 = three_vertex('t', 'r', 'l', -k, p, k-p)
t4 = three_vertex('x', 'l', 's', k, p-k, -p)

expr += calculate_vertices(t3*t4)

display(expr.subs(D, 4))

$\displaystyle (kk) g_{\rho\tau} g_{\sigma\xi} + (kk) g_{\rho\xi} g_{\sigma\tau} + 2 (kp) g_{\rho\tau} g_{\sigma\xi} + 2 (kp) g_{\rho\xi} g_{\sigma\tau} + (pp) g_{\rho\tau} g_{\sigma\xi} + (pp) g_{\rho\xi} g_{\sigma\tau} + 2 g_{\rho\sigma} k_{\tau} k_{\xi} - 4 g_{\rho\sigma} k_{\tau} p_{\xi} - 4 g_{\rho\sigma} k_{\xi} p_{\tau} + 8 g_{\rho\sigma} p_{\tau} p_{\xi} - 3 g_{\rho\tau} k_{\sigma} k_{\xi} + 3 g_{\rho\tau} k_{\xi} p_{\sigma} - 3 g_{\rho\tau} p_{\sigma} p_{\xi} - 3 g_{\rho\xi} k_{\sigma} k_{\tau} + 3 g_{\rho\xi} k_{\tau} p_{\sigma} - 3 g_{\rho\xi} p_{\sigma} p_{\tau} - 3 g_{\sigma\tau} k_{\rho} k_{\xi} + 3 g_{\sigma\tau} k_{\xi} p_{\rho} - 3 g_{\sigma\tau} p_{\rho} p_{\xi} - 3 g_{\sigma\xi} k_{\rho} k_{\tau} + 3 g_{\sigma\xi} k_{\tau} p_{\rho} - 3 g_{\sigma\xi} p_{\rho} p_{\tau} + 8 g_{\tau\xi} k_{\rho} k_{\sigma} - 4 g_{\tau\xi} k_{\rho} p_{\sigma} - 4 g_{\tau\xi} k_{\sigma} p_{\rho} + 2 g_{\tau\xi} p_{\rho} p_{\sigma}$

Final Project III

(f)

Feynman parametarsに対応

def moFP(momentum, index_abr, FPs):
    if momentum != 0:
        FPstr = [str(i) for i in FPs]
        terms = list(sympy.Add.make_args(momentum))
        momentum_indexed = 0
        for i in range(len(terms)):
            strterm = str(terms[i]).split("*")
            if len(strterm) == 1: # e.g. p
                term_indexed = str(terms[i]) + '_' + index_abr
                term_indexed = sympy.sympify(term_indexed, globals())
            elif len(set(strterm) & set(FPstr)) == 0: # e.g. 2*k (no Feynman parameters)
                term_indexed = str(terms[i]) + '_' + index_abr
                term_indexed = sympy.sympify(term_indexed, globals())
            else: # e.g. x*k -> put Feynman parameter (x, y) ahead of momentum
                for j in FPs:
                    if str(j) in strterm:
                        FP_index = strterm.index(str(j))
                        FP_extract = strterm.pop(FP_index)
                        term_indexed = [str(FP_extract)] + strterm
                        term_indexed = "*".join(term_indexed)
                        term_indexed = term_indexed + '_' + index_abr
                        term_indexed = sympy.sympify(term_indexed, globals())
            momentum_indexed += term_indexed
        return momentum_indexed
    else:
        return 0

def three_vertex_FP(m, n, r, k, p, q, FPs):
    if k+p+q != 0:
        print('momentum not conserved!')
    T1 = sympy.sympify('g_' + m + n, globals()) * (moFP(k - p, r, FPs))
    T2 = sympy.sympify('g_' + n + r, globals()) * (moFP(p - q, m, FPs))
    T3 = sympy.sympify('g_' + r + m, globals()) * (moFP(q - k, n, FPs))
    T = T1 + T2 + T3
    return T

Feynman parametersの定義

x, y = sympy.symbols("x, y")

$AW^+W^- + AW^+W^-$（ただし$k_1\to k$, $k_2\to K$とした）

# q = l - x*k + y*K
t1 = three_vertex_FP('s', 'r', 'm', l - x*k + y*K+k, -(l - x*k + y*K), -k, [x, y])
t2 = three_vertex_FP('r', 's', 'n', l - x*k + y*K, K-(l - x*k + y*K), -K, [x, y])
t12 = calculate_vertices(t1*t2)
# display(sympy.simplify(t12))
display(t12.subs([(kk, 0), (KK, 0), (kl, 0), (Kl, 0), (k_m, 0), (k_n, 0), (K_m, 0), (K_n, 0)]))

$\displaystyle - 4 (kK) g_{\mu\nu} x y + (kK) g_{\mu\nu} x + (kK) g_{\mu\nu} y - 5 (kK) g_{\mu\nu} + 2 (ll) g_{\mu\nu} + 4 D l_{\mu} l_{\nu} - 6 l_{\mu} l_{\nu}$

$AW^+W^- + AW^+W^-$

# q = l - x*k + y*K
t1 = three_vertex_FP('s', 'r', 'm', -(l - x*k + y*K), (l - x*k + y*K)+k, -k, [x, y])
t2 = three_vertex_FP('r', 's', 'n', K-(l - x*k + y*K), l - x*k + y*K, -K, [x, y])
t12 = calculate_vertices(t1*t2)
# display(sympy.simplify(t12))
display(t12.subs([(kk, 0), (KK, 0), (kl, 0), (Kl, 0), (k_m, 0), (k_n, 0), (K_m, 0), (K_n, 0)]))

$\displaystyle - 4 (kK) g_{\mu\nu} x y + (kK) g_{\mu\nu} x + (kK) g_{\mu\nu} y - 5 (kK) g_{\mu\nu} + 2 (ll) g_{\mu\nu} + 4 D l_{\mu} l_{\nu} - 6 l_{\mu} l_{\nu}$

$AW^+W^- + AW^-\phi^-$

# l - x*k + y*K
t1 = three_vertex_FP('s', 'n', 'm', (l - x*k + y*K)+k, -(l - x*k + y*K), -k, [x, y])
t2 = moFP((l - x*k + y*K) - k - 2*K, 's', [x, y])
t12 = calculate_vertices(t1*t2)
# display(sympy.simplify(t12))
display(t12.subs([(kk, 0), (KK, 0), (kl, 0), (Kl, 0), (k_m, 0), (k_n, 0), (K_m, 0), (K_n, 0)]))

$\displaystyle 2 (kK) g_{\mu\nu} x y - 2 (kK) g_{\mu\nu} x + 2 (kK) g_{\mu\nu} y - 2 (kK) g_{\mu\nu} - (ll) g_{\mu\nu} + l_{\mu} l_{\nu}$

$AW^+W^- + AW^-\phi^-$

# l - x*k + y*K
t1 = three_vertex_FP('n', 's', 'm', -(l - x*k + y*K), (l - x*k + y*K)+k, -k, [x, y])
t2 = moFP((l - x*k + y*K) - k - 2*K, 's', [x, y]) # = q - K - p
t12 = calculate_vertices(t1*t2)
# display(sympy.simplify(t12))
display(t12.subs([(kk, 0), (KK, 0), (kl, 0), (Kl, 0), (k_m, 0), (k_n, 0), (K_m, 0), (K_n, 0)]))

$\displaystyle - 2 (kK) g_{\mu\nu} x y + 2 (kK) g_{\mu\nu} x - 2 (kK) g_{\mu\nu} y + 2 (kK) g_{\mu\nu} + (ll) g_{\mu\nu} - l_{\mu} l_{\nu}$

$AW^-\phi^- + AW^+W^-$

# l - x*k + y*K
t1 = three_vertex_FP('s', 'm', 'n', -(l - x*k + y*K)+K, l - x*k + y*K, -K, [x, y])
t2 = moFP(-(l - x*k + y*K) - 2*k - K, 's', [x, y]) # = -q - K - p
t12 = calculate_vertices(t1*t2)
# display(sympy.simplify(t12))
display(t12.subs([(kk, 0), (KK, 0), (kl, 0), (Kl, 0), (k_m, 0), (k_n, 0), (K_m, 0), (K_n, 0)]))

$\displaystyle 2 (kK) g_{\mu\nu} x y + 2 (kK) g_{\mu\nu} x - 2 (kK) g_{\mu\nu} y - 2 (kK) g_{\mu\nu} - (ll) g_{\mu\nu} + l_{\mu} l_{\nu}$

$AW^+\phi^+ + AW^+W^-$

# l - x*k + y*K
t1 = three_vertex_FP('m', 's', 'n', (l - x*k + y*K), -(l - x*k + y*K)+K, -K, [x, y])
t2 = moFP(-(l - x*k + y*K) - 2*k - K, 's', [x, y]) # = -q - K - p
t12 = calculate_vertices(t1*t2)
# display(sympy.simplify(t12))
display(t12.subs([(kk, 0), (KK, 0), (kl, 0), (Kl, 0), (k_m, 0), (k_n, 0), (K_m, 0), (K_n, 0)]))

$\displaystyle - 2 (kK) g_{\mu\nu} x y - 2 (kK) g_{\mu\nu} x + 2 (kK) g_{\mu\nu} y + 2 (kK) g_{\mu\nu} + (ll) g_{\mu\nu} - l_{\mu} l_{\nu}$