def dgkv_potential(scalars, compactify_on='S3'):
"""Implements the potential (3.8) of arXiv:1009.3805."""
basis2 = tf.constant(util.get_symmetric_traceless_basis(2), dtype=tf.float64)
L = tf.constant(dict(S3=1, R3=0, H3=-1)[compactify_on], dtype=tf.float64)
s_phi, s_lambda, s_beta = scalars[0], scalars[1], scalars[2]
tau22 = tf.einsum('aAB,a->AB', basis2, scalars[3:5])
T = tf_cexpm.cexpm(tau22, complex_arg=False)
Tinv = tf_cexpm.cexpm(-tau22, complex_arg=False)
theta = scalars[5:7]
chi = scalars[7:9]
#
tr = tf.linalg.trace
esum = tf.einsum
sq = tf.math.square
exp = tf.exp
trT = tr(T)
th_Tinv_th = esum('a,ab,b->', theta, Tinv, theta)
return (
3 * L * exp(-10 * s_phi)
-3/8 * exp(8 * s_lambda - 14 * s_phi) * sq(
L - 2 * s_beta**2 - 2 * tf.einsum('a,a->', theta, theta))
+0.5 * exp(-6 * s_phi) * (
3 * exp(-8 * s_lambda)
+ exp(12 * s_lambda) * (sq(trT)
- 2 * esum('ab,ab->', T, T))
+ 6 * exp(2 * s_lambda) * trT)
-1.5 * exp(-10 * s_phi) * (
exp(10 * s_lambda) * esum('a,ab,b->', theta, T, theta)
- 2 * esum('a,a->', theta, theta)
+ exp(-10 * s_lambda) * th_Tinv_th)
-6 * exp(-2 * s_lambda -14 * s_phi) * sq(s_beta) * th_Tinv_th
-0.5 * exp(6 * s_lambda - 18 * s_phi) * esum('a,ab,b->', chi, T, chi))
def dim7_potential(scalars):
"""Implements the D=7 supergravity potential, (2.3) in arXiv:1906.08900."""
# This can be regarded as a warm-up exercise.
basis = tf.constant(util.get_symmetric_traceless_basis(5), dtype=tf.float64)
g = tf.einsum('aAB,a->AB', basis, scalars)
T = tf_cexpm.cexpm(g, complex_arg=False)
trT = tf.linalg.trace(T)
return tf.einsum('ij,ij->', T, T) - 0.5 * trT * trT
def cgr_potential(scalars, compactify_on='S2'):
"""Implements the potential (3.20) of arXiv:1906.08900."""
basis5 = tf.constant(util.get_symmetric_traceless_basis(3), dtype=tf.float64)
L = tf.constant(dict(S2=1, R2=0, H2=-1)[compactify_on], dtype=tf.float64)
# Psi_a_alpha, a in (0,1), alpha in (0,1,2).
psi = tf.reshape(scalars[:6], [2, 3])
psi2 = tf.einsum('aA,aA->', psi, psi)
# Parameters of a symmetric traceless 3x3 matrix.
# (This is slightly silly here, given that we can use a SO(3) rotation
# to diagonalize the generator.)
tau33 = tf.einsum('aAB,a->AB', basis5, scalars[6: 11])
s_phi, s_lambda = scalars[11], scalars[12] # Scalars phi and lambda.
p = 3 * s_phi - s_lambda # Scalar phi3.
s = tf.exp(-s_phi - 3 * s_lambda) # Scalar sigma.
sinv2 = tf.exp(2 * s_phi + 6 * s_lambda)
# Here, we try to keep the arithmetic graph shallow by hand-expanding powers.
# (We would not have to do that.)
s2 = s * s
s4 = s2 * s2
e = tf.exp(-p)
e2 = e * e
e3 = e2 * e
e4 = e2 * e2
e6 = e2 * e4
T = tf_cexpm.cexpm(tau33, complex_arg=False)
trT = T[0, 0] + T[1, 1] + T[2, 2] # Simplistic way to get trace.
Tinv = tf_cexpm.cexpm(-tau33, complex_arg=False)
psi_Tinv_psi = tf.einsum(
'aB,cB->ac', tf.einsum('aA,AB->aB', psi, Tinv), psi)
psi_T_psi = tf.einsum(
'aB,cB->ac', tf.einsum('aA,AB->aB', psi, T), psi)
ptp_ptp = ( # Manually expanded the \epsilon-factors here.
psi_Tinv_psi[0, 0] * psi_Tinv_psi[1, 1] + # a=0, c=0 => b=1, d=1.
psi_Tinv_psi[1, 1] * psi_Tinv_psi[0, 0] - # a=1, c=1 => b=0, d=0.
psi_Tinv_psi[0, 1] * psi_Tinv_psi[1, 0] - # a=0, c=1 => b=1, d=0.
psi_Tinv_psi[1, 0] * psi_Tinv_psi[0, 1]) # a=1, c=0 => b=0, d=1.
return ( # Formula (3.20) from the paper, sans factors g^2 and vol5.
s4 * (
- e4 * ptp_ptp
- e2 * (psi_Tinv_psi[0, 0] + psi_Tinv_psi[1, 1])) +
sinv2 * (
-0.5 * e6 * (L - psi2) * (L - psi2)
-e4 * (psi_T_psi[0, 0] + psi_T_psi[1, 1])
+e2 * (0.5 * trT * trT - tf.einsum('AB,BA->', T, T))) +
2 * s * (e3 * (L + psi2) + e * trT))
def _reduce_second_m35(m35s, m35c, is_diagonal_35s, seed=0):
"""Reduces the 2nd 35-irrep."""
diag = numpy.diagonal(m35s if is_diagonal_35s else m35c)
gens = _get_generators_for_reducing_second_m35(
diag,
'gsS,sScC->gcC' if is_diagonal_35s else 'gcC,sScC->gsS',
algebra.spin8.gamma_sscc)
num_gens = len(gens)
if num_gens == 0:
return m35s, m35c # No residual symmetry to exploit.
# This residual symmetry is typically rather small.
# So, doing a direct minimization is perhaps appropriate.
rng = numpy.random.RandomState(seed=seed)
v_coeffs_initial = rng.normal(
scale=1e-3, size=(num_gens,)) # Break symmetry with noise.
graph = tf.Graph()
with graph.as_default():
tc_gens = tf.constant(gens, dtype=tf.float64)
tc_m35 = tf.constant(m35c if is_diagonal_35s else m35s,
dtype=tf.float64)
t_coeffs = tf.Variable(initial_value=v_coeffs_initial,
trainable=True,
dtype=tf.float64)
t_rot = tf_cexpm.cexpm(tf.einsum('i,iab->ab', t_coeffs, tc_gens),
complex_arg=False)
t_m35_rotated = tf.einsum('Ab,Bb->AB',
tf.einsum('ab,Aa->Ab', tc_m35, t_rot), t_rot)
# Our 'loss' is the sum of magnitudes of the off-diagonal parts after
# rotation.
t_loss = (tf.norm(t_m35_rotated, ord=1) -
tf.norm(tf.linalg.diag_part(t_m35_rotated), ord=1))
optimizer = tf.contrib.opt.ScipyOptimizerInterface(t_loss)
with tf.compat.v1.Session() as sess:
sess.run([tf.global_variables_initializer()])
optimizer.minimize(sess)
# We are only interested in the diagonalized matrix.
m_diag = sess.run([t_m35_rotated])[0]
return (m35s, m_diag) if is_diagonal_35s else (m_diag, m35c)
