def baryon_decuplet_base_contraction(prop_1, prop_2, diquarks, pol_matrix):
assert isinstance(diquarks, list)
contraction = gpt.trace(
gpt.eval(pol_matrix * gpt.color_trace(prop_2 * gpt.spin_trace(diquarks[0]))) +
gpt.eval(pol_matrix * gpt.color_trace(prop_2 * diquarks[0]))
)
contraction += gpt.eval(gpt.trace(pol_matrix * gpt.color_trace(prop_2 * diquarks[1])))
contraction += gpt.eval(gpt.trace(pol_matrix * gpt.color_trace(prop_1 * diquarks[2])))
contraction *= 2
contraction += gpt.eval(gpt.trace(pol_matrix * gpt.color_trace(prop_1 * gpt.spin_trace(diquarks[2]))))
return contraction
def uud_two_point(Q1, Q2, kernel):
#
# eps(a,b,c) eps(a',b',c') (kernel)_alpha'beta' (kernel)_alphabeta Pp_gammagamma' Q2_beta'beta_b'b
# (Q1_alpha'alpha_a'a Q1_gamma'gamma_c'c - Q1_alpha'gamma_a'c Q1_gamma'alpha_c'a)
#
# =
#
# eps(a,b,c) eps(a',b',c') (kernel)_alpha'beta' (kernel)_alphabeta Pp_gammagamma' Q2_beta'beta_b'b
# Q1_alpha'alpha_a'a Q1_gamma'gamma_c'c
# -
# eps(a,b,c) eps(a',b',c') (kernel)_alpha'beta' (kernel)_alphabeta Pp_gammagamma' Q2_beta'beta_b'b
# Q1_alpha'gamma_a'c Q1_gamma'alpha_c'a
#
# =
#
# eps(c,a,b) eps(c',a',b') (Q1 kernel)_alpha'beta_a'a (kernel Q2)^Tspin_betaalpha'_b'b Tr_S[Pp Q1_c'c]
# +
# eps(a,b,c) eps(a',b',c') Pp_gammagamma'
# (Q1 kernel)_gamma'beta_c'c (kernel Q2)^Tspin_betaalpha'_b'b Q1_alpha'gamma_a'a
#
# =
#
# Tr_S[diquark(Q1 kernel, kernel Q2)_{cc'}] Tr_S[Pp Q1_c'c]
# +
# diquark(Q1 kernel, kernel Q2)_{gamma'alpha', aa'} Pp_gammagamma'
# Q1_alpha'gamma_a'a
#
# =
#
# Tr_C[Tr_S[diquark(Q1 kernel, kernel Q2)] Tr_S[Q1 Pp]]
# +
# Tr[ Q1 Pp diquark(Q1 kernel, kernel Q2) ]
#
#
# with
#
# diquark(Q1,Q2)_{gammagamma', cc'} = eps(c,a,b) eps(c',a',b') (Q1)_gammabeta_a'a (Q2)^Tspin_betagamma'_b'b
#
dq = g.qcd.baryon.diquark(g(Q1 * kernel), g(kernel * Q2))
return g(g.color_trace(g.spin_trace(dq) * Q1 + dq * Q1))
zero = g.vspincolor([[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]])
val = g.vspincolor([[1, 1, 1], [1, 1, 1], [0, 0, 0], [0, 0, 0]])
src[:] = 0
src[:, :, :, 0] = val
for x in range(grid.fdimensions[0]):
for t in range(grid.fdimensions[3]):
compare = val if t == 0 else zero
eps = g.norm2(src[x, 0, 0, t] - compare)
assert eps < 1e-13
# spin and color traces
mc = g.eval(g.spin_trace(msc))
assert g.norm2(mc[0, 0, 0, 0] - g.spin_trace(msc[0, 0, 0, 0])) < 1e-13
ms = g.eval(g.color_trace(msc))
assert g.norm2(ms[0, 0, 0, 0] - g.color_trace(msc[0, 0, 0, 0])) < 1e-13
eps0 = g.norm2(g.trace(msc) - g.spin_trace(ms))
eps1 = g.norm2(g.trace(msc) - g.color_trace(mc))
assert eps0 < 1e-9 and eps1 < 1e-9
# create singlet by number
assert g.complex(0.5).array[0] == 0.5
# test expression -> string conversion;
# at this point only make sure that it
# produces a string without failing
g.message(
f"Test string conversion of expression:\n{g.trace(0.5 * msc * msc - msc)}")
P = g.gamma[0] * g.gamma[1] - g.gamma[2] * g.gamma[3]
dst @= P * l
ref @= g.gamma[0] * g.gamma[1] * l - g.gamma[2] * g.gamma[3] * l
eps = g.norm2(dst - ref) / g.norm2(l)
g.message("Test Regular Expression: ", eps)
assert eps == 0.0
# test algebra versus matrix
for mu in [0, 1, 2, 3, 5, "I"]:
for op in [
lambda a, b: a * b,
lambda a, b: b * a,
lambda a, b: g.spin_trace(a * b),
lambda a, b: g.spin_trace(b * a),
lambda a, b: g.color_trace(a * b),
lambda a, b: g.color_trace(b * a),
lambda a, b: g.trace(a * b),
lambda a, b: g.trace(b * a),
]:
dst_alg = g(op(g.gamma[mu], l))
dst_mat = g(op(g.gamma[mu].tensor(), l))
eps2 = g.norm2(dst_alg - dst_mat) / g.norm2(dst_mat)
g.message(f"Algebra<>Matrix {mu}: {eps2}")
assert eps2 < 1e-14
# reconstruct and test the gamma matrix elements
for mu in g.gamma:
gamma = g.gamma[mu]
g.message("Test numpy matrix representation of", mu)
gamma_mu_mat = np.identity(4, dtype=np.complex128)
7.341488071688218e-06,
7.706037649768405e-06,
]
eps = np.linalg.norm(np.array(J5q) - np.array(J5q_ref))
g.message(f"J5q test: {eps}")
assert eps < 1e-5
# compute conserved current divergence
div = g.mspin(grid)
div[:] = 0
for mu in range(4):
tmp = qm.conserved_vector_current(dst_qm_bulk, src, dst_qm_bulk, src, mu)
tmp -= g.cshift(tmp, mu, -1)
div += g.color_trace(tmp)
div = g(g.trace(g.adj(div) * div))
g.message("div(conserved_current) contact term", div[0, 1, 0, 0].real)
div[0, 1, 0, 0] = 0
eps = g.sum(div).real
g.message(f"div(conserved_current) = {eps} without contact term")
assert eps < 1e-11
# compute partially conserved axial current divergence (zero momentum projected)
AP = g.slice(
g.trace(
qm.conserved_axial_current(dst_qm_bulk, src, dst_qm_bulk, src, 3) *
def sss_two_point(Q1, kernel):
dq = g.qcd.baryon.diquark(g(Q1 * kernel), g(kernel * Q1))
return g(-2.0 * g.color_trace(g.spin_trace(dq) * Q1 + 2.0 * dq * Q1))
def uud_two_point(Q1, Q2, kernel):
dq = g.qcd.baryon.diquark(g(Q1 * kernel), g(kernel * Q2))
return g(g.color_trace(g.spin_trace(dq) * Q1 + dq * Q1))
correlators[n, m, l, t] = c.real
# test gauge covariance
for k in range(len(contraction_routines)):
for t in range(Nt):
assert (correlators[0, k, l, t] - correlators[1, k, l, t] < 1e-12)
# test spin structure
for n in range(4):
I = g.ot_matrix_spin_color(4, 3).identity()
if (n == 0):
di_quark1 = qC.quark_contract_12(dst, dst)
di_quark2 = qC.quark_contract_12(dst, g.eval(I * g.spin_trace(dst)))
correlator1 = g.slice(g.trace(di_quark1), 3)
correlator2 = g.slice(g.color_trace(di_quark2), 3)
for t in range(Nt):
assert (correlator1[t] - correlator2[t][0, 0]) < 1e-13
if (n == 1):
di_quark1 = qC.quark_contract_34(dst, dst)
di_quark2 = qC.quark_contract_34(g.eval(I * g.spin_trace(dst)), dst)
correlator1 = g.slice(g.trace(di_quark1), 3)
correlator2 = g.slice(g.color_trace(di_quark2), 3)
for t in range(Nt):
assert (correlator1[t] - correlator2[t][0, 0]) < 1e-13
if (n == 2):
def contract_three_flavor_baryon(prop_1, prop_2, prop_3, pol_matrix, source_spin_matrix, sink_spin_matrix):
di_quark = quark_contract_13(gpt.eval(prop_1 * source_spin_matrix), gpt.eval(sink_spin_matrix * prop_2))
return gpt.trace(gpt.eval(pol_matrix * gpt.color_trace(prop_3 * gpt.spin_trace(di_quark))))
def contract_lambda_naive(prop_up, prop_down, prop_strange, spin_matrix, pol_matrix, diquark=None):
if diquark is None:
diquark = quark_contract_13(
gpt.eval(prop_up * spin_matrix), gpt.eval(spin_matrix * prop_down)
)
return gpt.trace(pol_matrix * gpt.color_trace(prop_strange * gpt.spin_trace(diquark)))
def baryon_octet_base_contraction(prop, diquark, pol_matrix):
return gpt.trace(
pol_matrix * gpt.color_trace(prop * gpt.spin_trace(diquark)) +
pol_matrix * gpt.color_trace(prop * diquark)
)
