def test_christ_flat():
"""now test that christofel preserve metrics:
on the flat space
d_xi <v M v> = 2 <v M nabla_xi v>
v = proj(W) @ (aa W + b)
"""
alpha = randint(1, 10, 2) * .1
beta = randint(1, 10, 2)[0] * .1
n = 20
d = 3
man = ComplexPositiveSemidefinite(n, d, alpha=alpha, beta=beta)
S = man.rand()
xi = man.randvec(S)
xi = man.randvec(S)
aa = crandn(n * d, n * d)
bb = crandn(n * d)
cc = crandn(d * d, d * d)
dd = hsym(crandn(d, d))
def v_func_flat(S):
# a function from the manifold
# to ambient
csp = hsym((cc @ S.P.reshape(-1)).reshape(d, d))
return psd_ambient((aa @ S.Y.reshape(-1) + bb).reshape(n, d), csp + dd)
vv = v_func_flat(S)
dlt = 1e-7
Snew = psd_point(S.Y + dlt * xi.tY, S.P + dlt * xi.tP)
vnew = v_func_flat(Snew)
val = man.inner_product_amb(S, vv)
valnew = man.inner_product_amb(Snew, vnew)
d1 = (valnew - val) / dlt
dv = (vnew - vv).scalar_mul(1 / dlt)
nabla_xi_v = dv + man.g_inv(S, man.christoffel_form(S, xi, vv))
nabla_xi_va = dv + man.g_inv(
S,
super(ComplexPositiveSemidefinite, man).christoffel_form(S, xi, vv))
print(check_zero(man._vec(nabla_xi_v) - man._vec(nabla_xi_va)))
d2 = man.inner(S, vv, nabla_xi_v)
print(d1)
print(2 * d2)
def test_rhess_02():
n, d = (50, 3)
alpha = randint(1, 10, 2) * .1
beta = randint(1, 10, 2)[0] * .1
man = ComplexPositiveSemidefinite(n, d, alpha=alpha, beta=beta)
S = man.rand()
# simple function. Distance to a given matrix
# || S - A||_F^2
A = hsym(crandn(n, n))
def f(S):
diff = (A - S.Y @ S.P @ S.Y.T.conjugate())
return trace(diff @ diff.T.conjugate())
def df(S):
return psd_ambient(-4 * A @ S.Y @ S.P,
2 * (S.P - S.Y.T.conjugate() @ A @ S.Y))
def ehess_form(S, xi, eta):
return (
trace(-4 * A @ (xi.tY @ S.P + S.Y @ xi.tP) @ eta.tY.T.conjugate())
+ 2 * trace(
(xi.tP - xi.tY.T.conjugate() @ A @ S.Y -
S.Y.T.conjugate() @ A @ xi.tY) @ eta.tP.T.conjugate())).real
def ehess_vec(S, xi):
return psd_ambient(
-4 * A @ (xi.tY @ S.P + S.Y @ xi.tP),
2 * (xi.tP - xi.tY.T.conjugate() @ A @ S.Y -
S.Y.T.conjugate() @ A @ xi.tY))
xxi = man.randvec(S)
dlt = 1e-8
Snew = psd_point(S.Y + dlt * xxi.tY, S.P + dlt * xxi.tP)
d1 = (f(Snew) - f(S)) / dlt
d2 = df(S)
print(d1 - man.base_inner_ambient(d2, xxi))
eeta = man.randvec(S)
d1 = man.base_inner_ambient((df(Snew) - df(S)), eeta) / dlt
ehess_val = ehess_form(S, xxi, eeta)
dv2 = ehess_vec(S, xxi)
print(man.base_inner_ambient(dv2, eeta))
print(d1, ehess_val, d1 - ehess_val)
# now check the formula: ehess = xi (eta_func(f)) - <D_xi eta, df(Y)>
# promote eta to a vector field.
m1 = crandn(n, n)
m2 = crandn(d, d)
m_p = crandn(d * d, d * d)
def eta_field(Sin):
return man.proj(
S,
psd_ambient(m1 @ (Sin.Y - S.Y) @ m2,
hsym((m_p @ (Sin.P - S.P).reshape(-1)).reshape(
d, d)))) + eeta
# xietaf: should go to ehess(xi, eta) + df(Y) @ etafield)
xietaf = (man.base_inner_ambient(df(Snew), eta_field(Snew)) -
man.base_inner_ambient(df(S), eta_field(S))) / dlt
# appy eta_func to f: should go to tr(m1 @ xxi @ m2 @ df(Y).T)
Dxietaf = man.base_inner_ambient(
(eta_field(Snew) - eta_field(S)), df(S)) / dlt
# this is ehess. should be same as d1 or ehess_val
print(xietaf - Dxietaf)
print(xietaf - Dxietaf - ehess_val)
# now check: rhess. Need to make sure xi, eta in the tangent space.
# first compare this with numerical differentiation
xi1 = man.proj(S, xxi)
eta1 = man.proj(S, eeta)
egvec = df(S)
ehvec = ehess_vec(S, xi1)
rhessvec = man.ehess2rhess(S, egvec, ehvec, xi1)
# check it numerically:
def rgrad_func(Y):
return man.proj_g_inv(Y, df(Y))
# val2a, _, _ = calc_covar_numeric_raw(man, W, xi1, df)
val2, _, _ = calc_covar_numeric(man, S, xi1, rgrad_func)
val2_p = man.proj(S, val2)
# print(rhessvec)
# print(val2_p)
print(man._vec(rhessvec - val2_p))
rhessval = man.inner_product_amb(S, rhessvec, eta1)
print(man.inner_product_amb(S, val2, eta1))
print(rhessval)
# check symmetric:
ehvec_e = ehess_vec(S, eta1)
rhessvec_e = man.ehess2rhess(S, egvec, ehvec_e, eta1)
rhessval_e = man.inner_product_amb(S, rhessvec_e, xi1)
print(rhessval_e)
# the above computed inner_prod(Nabla_xi Pi * df, eta)
# in the following check. Extend eta1 to eta_proj
# (Pi Nabla_hat Pi g_inv df, g eta)
# = D_xi (Pi g_inv df, g eta) - (Pi g_inv df g Pi Nabla_hat eta)
def eta_proj(S):
return man.proj(S, eta_field(S))
print(check_zero(man._vec(eta1 - eta_proj(S))))
e1 = man.inner(S, man.proj_g_inv(S, df(S)), eta_proj(S))
e1a = man.base_inner_ambient(df(S), eta_proj(S))
print(e1, e1a, e1 - e1a)
Snew = psd_point(S.Y + dlt * xi1.tY, S.P + dlt * xi1.tP)
e2 = man.inner(Snew, man.proj_g_inv(Snew, df(Snew)), eta_proj(Snew))
e2a = man.base_inner_ambient(df(Snew), eta_proj(Snew))
print(e2, e2a, e2 - e2a)
first = (e2 - e1) / dlt
first1 = (man.base_inner_ambient(df(Snew), eta_proj(Snew)) -
man.base_inner_ambient(df(S), eta_proj(S))) / dlt
print(first - first1)
val3, _, _ = calc_covar_numeric(man, S, xi1, eta_proj)
second = man.inner(S, man.proj_g_inv(S, df(S)), man.proj(S, val3))
second2 = man.inner(S, man.proj_g_inv(S, df(S)), val3)
print(second, second2, second - second2)
print('same as rhess_val %f' % (first - second))
def test_all_projections():
alpha = randint(1, 10, 2) * .1
beta = randint(1, 10, 1)[0] * .02
n = 5
d = 3
man = ComplexPositiveSemidefinite(n, d, alpha=alpha, beta=beta)
print(man)
S = man.rand()
test_inner(man, S)
test_J(man, S)
# now check metric, Jst etc
# check Jst: vectorize the operator J then compare Jst with jmat.T
jmat = make_j_mat(man, S)
test_Jst(man, S, jmat)
ginv_mat = make_g_inv_mat(man, S)
ee = man._rand_ambient()
g1 = man._unvec(ginv_mat @ man._vec(ee))
print(check_zero(man.g_inv(S, ee).tP - g1.tP))
print(check_zero(man.g_inv(S, ee).tY - g1.tY))
# test g_inv_Jst
for ii in range(10):
a = man._rand_range_J()
avec = man._vec_range_J(a)
jtout = ginv_mat @ jmat.T @ avec
jtout2 = man._vec(man.g_inv_Jst(S, a))
diff = check_zero(jtout - jtout2)
print(diff)
# test projection
test_projection(man, S)
# now diff projection
for i in range(1):
e = man._rand_ambient()
S1 = man.rand()
xi = man.randvec(S1)
dlt = 1e-7
S2 = psd_point(S1.Y + dlt * xi.tY, S1.P + dlt * xi.tP)
# S = psd_point(S1.Y, S1.P)
d1P = (man.proj(S2, e).tP - man.proj(S1, e).tP) / dlt
d1Y = (man.proj(S2, e).tY - man.proj(S1, e).tY) / dlt
d2 = man.D_proj(S1, xi, e)
print(check_zero(d1P - d2.tP) + check_zero(d1Y - d2.tY))
for i in range(10):
a = man._rand_range_J()
eta = man._rand_ambient()
print(man.base_inner_ambient(eta, man.Jst(S, a)))
print((trace((eta.tP.T.conjugate() - eta.tP) @ a['P'] +
(man.alpha[1] * eta.tY.T.conjugate() @ S.Y + man.beta *
(S.Pinv @ eta.tP.T.conjugate() -
eta.tP.T.conjugate() @ S.Pinv)) @ a['YP'])).real)
print((trace(2 * eta.tP.T.conjugate() @ a['P']) + trace(
(man.alpha[1] * eta.tY.T.conjugate() @ S.Y + man.beta *
(S.Pinv @ eta.tP.T.conjugate() - eta.tP.T.conjugate() @ S.Pinv))
@ a['YP'])).real)
print((trace(
eta.tP.T.conjugate() @ (2 * a['P'] + man.beta *
(a['YP'] @ S.Pinv - S.Pinv @ a['YP']))) +
trace(eta.tY.T.conjugate() @ (man.alpha[1] * S.Y @ a['YP']))
).real)
print(man.base_inner_E_J(man.J(S, eta), a))
print((
trace((eta.tP - eta.tP.T.conjugate()).T.conjugate() @ a['P'] +
(man.alpha[1] * S.Y.T.conjugate() @ eta.tY + man.beta *
(eta.tP @ S.Pinv - S.Pinv @ eta.tP)).T.conjugate() @ a['YP']
)).real)
for i in range(10):
a = man._rand_range_J()
beta = man.beta
alf = man.alpha
anew1 = man.J(S, man.g_inv_Jst(S, a))
anew = {}
saYP = a['YP'] + a['YP'].T.conjugate()
anew['P'] = 4 / beta * S.P @ a['P'] @ S.P + S.P @ saYP - saYP @ S.P
anew['YP'] = alf[1] * a['YP'] + beta * (
((2 / man.beta) * S.P @ a['P'] @ S.P + S.P @ a['YP'] -
a['YP'] @ S.P) @ S.Pinv - S.Pinv @ (
(2 / man.beta) * S.P @ a['P'] @ S.P + S.P @ a['YP'] -
a['YP'] @ S.P))
anew['YP'] = alf[1] * a['YP'] + (
(2 * S.P @ a['P'] + beta * S.P @ a['YP'] @ S.Pinv - beta * a['YP'])
- (2 * a['P'] @ S.P + beta * a['YP'] -
beta * S.Pinv @ a['YP'] @ S.P))
anew['YP'] = (alf[1] - 2 * beta) * a['YP'] + (
(2 * S.P @ a['P'] + beta * S.P @ a['YP'] @ S.Pinv) -
(2 * a['P'] @ S.P - beta * S.Pinv @ a['YP'] @ S.P))
anew['YP'] = (alf[1] - 2 * beta) * a['YP'] + (
(2 * S.P @ a['P'] - 2 * a['P'] @ S.P +
beta * S.P @ a['YP'] @ S.Pinv + beta * S.Pinv @ a['YP'] @ S.P))
print(check_zero(man._vec_range_J(anew1) - man._vec_range_J(anew)))
for i in range(10):
a = man._rand_range_J()
b1 = man.J(S, man.g_inv_Jst(S, a))
b2 = man.J_g_inv_Jst(S, a)
print(check_zero(man._vec_range_J(b1) - man._vec_range_J(b2)))
a1 = man.solve_J_g_inv_Jst(S, b1)
print(check_zero(man._vec_range_J(a) - man._vec_range_J(a1)))
for ii in range(10):
E = man._rand_ambient()
a2 = man.J_g_inv(S, E)
a1 = man.J(S, man.g_inv(S, E))
print(check_zero(man._vec_range_J(a1) - man._vec_range_J(a2)))
for i in range(20):
Uran = man._rand_ambient()
Upr = man.proj(S, man.g_inv(S, Uran))
Upr2 = man.proj_g_inv(S, Uran)
print(check_zero(man._vec(Upr) - man._vec(Upr2)))
for ii in range(10):
a = man._rand_range_J()
xi = man.randvec(S)
jtout2 = man.Jst(S, a)
dlt = 1e-7
Snew = psd_point(S.Y + dlt * xi.tY, S.P + dlt * xi.tP)
jtout2a = man.Jst(Snew, a)
d1 = (jtout2a - jtout2).scalar_mul(1 / dlt)
d2 = man.D_Jst(S, xi, a)
print(check_zero(man._vec(d2) - man._vec(d1)))
for ii in range(10):
S1 = man.rand()
eta = man._rand_ambient()
xi = man.randvec(S1)
a1 = man.J(S1, eta)
dlt = 1e-8
Snew = psd_point(S1.Y + dlt * xi.tY, S1.P + dlt * xi.tP)
a2 = man.J(Snew, eta)
d1 = {
'P': (a2['P'] - a1['P']) / dlt,
'YP': (a2['YP'] - a1['YP']) / dlt
}
d2 = man.D_J(S1, xi, eta)
print(check_zero(man._vec_range_J(d2) - man._vec_range_J(d1)))
# derives metrics
for ii in range(10):
S1 = man.rand()
xi = man.randvec(S1)
omg1 = man._rand_ambient()
omg2 = man._rand_ambient()
dlt = 1e-7
S2 = psd_point(S1.Y + dlt * xi.tY, S1.P + dlt * xi.tP)
p1 = man.inner(S1, omg1, omg2)
p2 = man.inner(S2, omg1, omg2)
der1 = (p2 - p1) / dlt
der2 = man.base_inner_ambient(man.D_g(S1, xi, omg2), omg1)
print(der1 - der2)
if np.abs(der1 - der2) > 1e-4:
print(der1, der2)
break
# cross term for christofel
for i in range(10):
S1 = man.rand()
xi = man.randvec(S1)
eta1 = man.randvec(S1)
eta2 = man.randvec(S1)
dr1 = man.D_g(S1, xi, eta1)
x12 = man.contract_D_g(S1, eta1, eta2)
p1 = man.base_inner_ambient(dr1, eta2)
p2 = man.base_inner_ambient(x12, xi)
print(p1, p2, p1 - p2)
# now test christofel:
# two things: symmetric on vector fields
# and christofel relation
# in the case metric
for i in range(10):
S1 = man.rand()
xi = man.randvec(S1)
eta1 = man.randvec(S1)
eta2 = man.randvec(S1)
p1 = man.proj_g_inv(S1, man.christoffel_form(S1, xi, eta1))
p2 = man.proj_g_inv(S1, man.christoffel_form(S1, eta1, xi))
print(check_zero(man._vec(p1) - man._vec(p2)))
v1 = man.base_inner_ambient(man.christoffel_form(S1, eta1, eta2), xi)
v2 = man.base_inner_ambient(man.D_g(S1, eta1, eta2), xi)
v3 = man.base_inner_ambient(man.D_g(S1, eta2, eta1), xi)
v4 = man.base_inner_ambient(man.D_g(S1, xi, eta1), eta2)
print(v1, 0.5 * (v2 + v3 - v4), v1 - 0.5 * (v2 + v3 - v4))