def test_topology_type():
"""(DL)^{i} L^{j} (DH)^{k} (DDH)^{l}"""
eff_ops = [
EffectiveOperator("", op)
for op in invariants(D(L, "01"), L, D(H, "11"), D(D(H, "11"), "22"))
]
assert eff_ops[0].topology_type == {"n_scalars": 2, "n_fermions": 2}
def test_get_lorentz_epsilons():
passes, epsilons = get_lorentz_epsilons((D(D(H, "11"),
"00")("i0"), H("i1")))
assert passes
assert not epsilons
passes, epsilons = get_lorentz_epsilons(
(D(H, "11")("u0 d0 i0"), D(H, "11")("u1 d1 i1")))
assert passes
assert epsilons == [eps("-u0 -u1"), eps("-d0 -d1")]
passes, epsilons = get_lorentz_epsilons((Q("u0 c0 i0"), L("u1 i1")))
assert passes
assert epsilons == [eps("-u0 -u1")]
passes, epsilons = get_lorentz_epsilons((Q("u0 c0 i0"), L.conj("d1 i1")))
assert not passes
assert not epsilons
passes, epsilons = get_lorentz_epsilons(
(D(L, "01")("d0 i0"), D(H, "11")("u0 d1 i1")))
assert passes
assert epsilons == [eps("-d0 -d1")]
passes, epsilons = get_lorentz_epsilons(
(D(Q, "01")("d0 c0 i0"), D(L, "01")("d1 i1")))
assert passes
assert epsilons == [eps("-d0 -d1")]
def test_derivs_nlo_completions():
# Derivative operator examples:
from neutrinomass.tensormethod.sm import L, H
from neutrinomass.tensormethod.core import D
o1box = EffectiveOperator(
"O1box",
L("u0 i0") * L("u1 i1") * D(H, "11")("u2 d0 i2") *
D(H, "11")("u3 d1 i3") * eps("-i0 -i2") * eps("-i1 -i3"),
)
comps = collect_completions(operator_completions(o1box))
assert len(comps) == 3
assert not filter_completions(comps, SIEVE)
def test_process_derivative_term():
n = 10
symbols = {
"fermion": list(map(lambda i: "F" + str(i), range(n))),
"boson": list(map(lambda i: "F" + str(i), range(n))),
}
exotic_dict = {}
# Dirac fermion, deriv on fermion
_, _, term = exotic_field_and_term(
H("i1") * D(Q, "01")("d0 c0 i0"), symbols, exotic_dict)
assert process_derivative_term(term)
# Dirac fermion, deriv on scalar
_, _, term = exotic_field_and_term(
D(H, "11")("u0 d0 i1") * Q("u1 c0 i0") * eps("-u0 -u1"), symbols,
exotic_dict)
assert process_derivative_term(term)
# Majorana fermion
_, _, term = exotic_field_and_term(
D(H, "11")("u0 d0 i1") * L("u1 i0") * eps("-u0 -u1"), symbols,
exotic_dict)
assert process_derivative_term(term)
# Two derivatives, scalar case
_, _, term = exotic_field_and_term(
D(H, "11")("u0 d0 i1") * D(H, "11")("u1 d1 i0") * eps("-u0 -u1") *
eps("-d0 -d1"),
symbols,
exotic_dict,
)
assert process_derivative_term(term)
# Two derivatives, scalar case, four point
_, _, term = exotic_field_and_term(
D(H, "11")("u0 d0 i1") * D(H, "11")("u1 d1 i0") * H("i2") *
eps("-u0 -u1") * eps("-d0 -d1"),
symbols,
exotic_dict,
)
assert process_derivative_term(term)
# Two derivatives, fermion case
_, _, term = exotic_field_and_term(
D(L, "01")("d0 i1") * D(L, "01")("d1 i0") * eps("-d0 -d1"), symbols,
exotic_dict)
assert process_derivative_term(term)
# Regular fermion case, for comparison above (and check on exotic_dict)
_, _, term = exotic_field_and_term(
L("u0 i1") * L("u1 i0") * eps("-u0 -u1"), symbols, exotic_dict)
assert process_derivative_term(term)
def test_strip_derivs():
from neutrinomass.tensormethod.sm import Q, H
from neutrinomass.tensormethod.core import D
return D(D(Q, "01"), "10")("u0 c0 i0").strip_derivs_with_indices()
assert D(D(Q, "01"),
"10")("u0 c0 i0").strip_derivs_with_indices() == Q("u0 c0 i0")
assert D(D(H, "11"), "00")("i0").strip_derivs_with_indices() == H("i0")
assert D(Q, "01").strip_derivs_with_indices().derivs == 0
def test_deriv_completions():
# operators from the dimension-6 SMEFT
from neutrinomass.tensormethod.sm import H, eb
from neutrinomass.tensormethod.core import D
Ophie_D1 = invariants(D(H, "11"), H.conj, eb.conj, eb)[0]
Ophie_D2 = invariants(H, D(H.conj, "11"), eb.conj, eb)[0]
Ophie_D3 = invariants(H, H.conj, D(eb.conj, "10"), eb)[0]
Ophie_D4 = invariants(H, H.conj, eb.conj, D(eb, "01"))[0]
eff_ophie_D1 = EffectiveOperator("OphieD1", Ophie_D1)
eff_ophie_D2 = EffectiveOperator("OphieD2", Ophie_D2)
eff_ophie_D3 = EffectiveOperator("OphieD3", Ophie_D3)
eff_ophie_D4 = EffectiveOperator("OphieD4", Ophie_D4)
models = {
op.name: sorted(collect_completions(operator_completions(op)))
for op in [eff_ophie_D1, eff_ophie_D2, eff_ophie_D3, eff_ophie_D4]
}
assert models["OphieD1"] == models["OphieD2"]
assert models["OphieD1"] == models["OphieD3"]
assert models["OphieD1"] == models["OphieD4"]
def test_ophibox_ophiD():
"""Example from section 2.2 in the paper."""
from neutrinomass.tensormethod.sm import H
from neutrinomass.tensormethod.core import D
ohhdd1 = EffectiveOperator(
"OHHDD1",
H.conj("i0") * H.conj("i1") * D(H, "11")("u0 d0 i2") *
D(H, "11")("u1 d1 i3") * eps("-i0 -i2") * eps("-i1 -i3"),
)
ohhdd2 = EffectiveOperator(
"OHHDD2",
H.conj("i0") * H("i1") * D(H.conj, "11")("u0 d0 i2") *
D(H, "11")("u1 d1 i3") * eps("-i0 -i1") * eps("-i2 -i3"),
)
ohhdd3 = EffectiveOperator(
"OHHDD3",
H.conj("i0") * H("i1") * D(H.conj, "11")("u0 d0 i2") *
D(H, "11")("u1 d1 i3") * eps("-i0 -i2") * eps("-i1 -i3"),
)
ohhdd4 = EffectiveOperator(
"OHHDD4",
H.conj("i0") * H("i1") * D(H.conj, "11")("u0 d0 i2") *
D(H, "11")("u1 d1 i3") * eps("-i0 -i3") * eps("-i1 -i2"),
)
comps = {}
for op in [ohhdd1, ohhdd2, ohhdd3, ohhdd4]:
comps[op.name] = list(collect_completions(operator_completions(op)))
assert len(comps["OHHDD1"]) == 1
assert len(comps["OHHDD2"]) == 1
assert len(comps["OHHDD3"]) == 1
assert len(comps["OHHDD4"]) == 1
assert comps["OHHDD1"][0] == (("S", 0, 0, 2, ("3b", 0), ("y", 1)), )
assert comps["OHHDD2"][0] == (("S", 0, 0, 0, ("3b", 0), ("y", 0)), )
assert comps["OHHDD3"][0] == (("S", 0, 0, 2, ("3b", 0), ("y", 0)), )
assert comps["OHHDD4"][0] == (("S", 0, 0, 2, ("3b", 0), ("y", 0)), )
def test_ibp():
from itertools import combinations
from collections import defaultdict
od12_1 = EffectiveOperator(
"OD12_1",
D(L, "01")("d3 i0 g0") * Q("u1 c1 i1 g1") * eb.conj("d0 g2") *
db("u2 -c2") * H("i2") * H("i3") * eps("-i0 -i2") * eps("-i1 -i3"),
)
od12_2 = EffectiveOperator(
"OD12_2",
L("u0 i0 g0") * D(Q, "01")("d3 c1 i1 g1") * eb.conj("d0 g2") *
db("u2 -c2") * H("i2") * H("i3") * eps("-i0 -i2") * eps("-i1 -i3"),
)
od12_3 = EffectiveOperator(
"OD12_3",
L("u0 i0 g0") * Q("u1 c1 i1 g1") * D(eb.conj, "10")("u5 g2") *
db("u2 -c2") * H("i2") * H("i3") * eps("-i0 -i2") * eps("-i1 -i3"),
)
od12_4 = EffectiveOperator(
"OD12_4",
L("u0 i0 g0") * Q("u1 c1 i1 g1") * eb.conj("d0 g2") *
D(db, "01")("d5 -c2") * H("i2") * H("i3") * eps("-i0 -i2") *
eps("-i1 -i3"),
)
od12_5 = EffectiveOperator(
"OD12_5",
L("u0 i0 g0") * Q("u1 c1 i1 g1") * eb.conj("d0 g2") * db("u2 -c2") *
D(H, "11")("u3 d1 i2") * H("i3") * eps("-i0 -i2") * eps("-i1 -i3"),
)
od12_6 = EffectiveOperator(
"OD12_6",
L("u0 i0 g0") * Q("u1 c1 i1 g1") * eb.conj("d0 g2") * db("u2 -c2") *
H("i2") * D(H, "11")("u3 d1 i3") * eps("-i0 -i2") * eps("-i1 -i3"),
)
models = {
op.name: sorted(collect_completions(operator_completions(op)))
for op in [od12_1, od12_2, od12_3, od12_4, od12_5, od12_6]
}
model_names = list(map(lambda i: "OD12_" + str(i), range(1, 7)))
model_dict = defaultdict(set)
for a, b in combinations(model_names, 2):
for model in models[a]:
if model in models[b]:
model_dict[model].add(a)
model_dict[model].add(b)
return model_dict
def derivative_combinations(
op: Union[Operator, EffectiveOperator]
) -> Union[List[Operator], List[EffectiveOperator]]:
"""Takes an operator with derivatives and returns a list of operators with
equivalent SU2 structure with the derivative acted in all possible ways.
Function expects a specific kind of input: no double derivatives on a single
field.
"""
eff_op = None
if isinstance(op, EffectiveOperator):
eff_op = op
op = op.operator
fields, epsilons, n_derivs = operator_strip_derivs(op).values()
deriv_id_func = lambda x: x
act_deriv = lambda f: D(f, allowed_lor_dyn(f))
deriv_tuple = [act_deriv for _ in range(n_derivs)] + [
deriv_id_func for _ in range(len(fields) - n_derivs)
]
structs, out = [], []
for perm in permutations(deriv_tuple):
new_structure = []
for field, func in zip(fields, perm):
new_structure.append((func(field[0]), field[1]))
structs.append(new_structure)
remove_equivalent(structs, eq_func=lambda x, y: x == y)
for struct in structs:
new_op = construct_operator(struct, epsilons)
if new_op.safe_simplify():
out.append(new_op)
return [EffectiveOperator(eff_op.name, i) for i in out] if eff_op else out
def test_1204_5986_completions():
"""Paper 1204.5986 lists UV completions of some derivative operators. Check
output of program against these results.
"""
from neutrinomass.tensormethod.sm import eb, H, L
from neutrinomass.tensormethod.core import D
# fields
k = ("S", 0, 0, 0, ("3b", 0), ("y", 2))
xi1 = ("S", 0, 0, 2, ("3b", 0), ("y", 1))
sigma = ("F", 0, 0, 2, ("3b", 0), ("y", 0))
ltilde = ("F", 0, 0, 1, ("3b", 0), ("y", Rational("1/2")))
z = ("S", 0, 0, 1, ("3b", 0), ("y", Rational("3/2")))
nur = ("F", 0, 0, 0, ("3b", 0), ("y", 0))
# their notation
phi_0_2 = ("S", 0, 0, 0, ("3b", 0), ("y", 2))
phi_12_32 = ("S", 0, 0, 1, ("3b", 0), ("y", Rational("3/2")))
phi_1_1 = ("S", 0, 0, 2, ("3b", 0), ("y", 1))
psi_1_0 = ("F", 0, 0, 2, ("3b", 0), ("y", 0))
psi_12_12 = ("F", 0, 0, 1, ("3b", 0), ("y", Rational("1/2")))
psi_0_0 = ("F", 0, 0, 0, ("3b", 0), ("y", 0))
o9 = EffectiveOperator(
"O9",
D(H, "11")("u0 d0 i0") * D(H, "11")("u1 d1 i1") * H("i2") * H("i3") *
eb.conj("d2 g0") * eb.conj("d3 g1") * eps("-i0 -i2") * eps("-i1 -i3"),
)
# models from table 5 in 1204.5986 (the ones implying vanishing vertices
# have been left out)
o9_models_from_paper = {
# first topology
frozenset([phi_0_2, phi_12_32, phi_1_1]),
frozenset([psi_12_12, phi_12_32, phi_1_1]),
frozenset([psi_12_12, psi_1_0, phi_1_1]),
frozenset([psi_12_12, psi_0_0]),
frozenset([psi_12_12, psi_1_0]),
frozenset([phi_1_1, psi_1_0]),
# second topology
frozenset([phi_0_2, phi_1_1]),
frozenset([psi_12_12, phi_1_1]),
}
o7_models_from_paper = {
frozenset([psi_1_0, phi_1_1]),
frozenset([psi_12_12, phi_1_1]),
frozenset([psi_12_12, psi_0_0]),
frozenset([psi_12_12, psi_1_0]),
}
o7 = EffectiveOperator(
"O7",
eb.conj("d0 g0") * L("u0 i0") * D(H, "11")("u1 d1 i1") * H("i2") *
H("i3") * eps("-i0 -i2") * eps("-i1 -i3"),
)
o7_comps = collect_completions(operator_completions(o7))
o9_comps = collect_completions(operator_completions(o9))
out = []
for comps, models in [
(o7_comps, o7_models_from_paper),
(o9_comps, o9_models_from_paper),
]:
for k, v in comps.items():
# we have, they don't have
if frozenset(k) not in models:
print("They don't have:")
print((k, v))
out.append((k, v))
for model in models:
# they have, we don't have
if model not in set(map(frozenset, comps.keys())):
print("We don't have:")
print(model)
assert not out