def calc_covar_numeric(man, S, xi, v_func):
""" compute nabla on E dont do the metric
lower index. So basically
Nabla (Pi e).
Thus, if we want to do Nabla Pi g_inv df
We need to send g_inv df
"""
def vv_func(W):
return man.proj(W, v_func(W))
vv = vv_func(S)
dlt = 1e-7
Snew = fr_point(S.U + dlt * xi.tU, S.V + dlt * xi.tV, S.P + dlt * xi.tP)
vnew = vv_func(Snew)
val = man.inner(S, vv)
valnew = man.inner(Snew, vnew)
d1 = (valnew - val) / dlt
dv = (vnew - vv).scalar_mul(1 / dlt)
cx = man.christoffel_form(S, xi, vv)
nabla_xi_v_up = dv + man.g_inv(S, cx)
nabla_xi_v = man.proj(S, nabla_xi_v_up)
if False:
d2 = man.inner_product_amb(S, vv, nabla_xi_v)
d2up = man.inner_product_amb(S, vv, nabla_xi_v_up)
print(d1)
print(2 * d2up)
print(2 * d2)
return nabla_xi_v, dv, cx
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
gamma = randint(1, 10, 2) * .1
beta = randint(1, 10, 2)[0] * .1
m = 4
n = 5
p = 3
man = RealFixedRank(m, n, p, alpha=alpha, beta=beta, gamma=gamma)
S = man.rand()
xi = man.randvec(S)
aaU = randn(m * p, m * p)
bbU = randn(m * p)
aaV = randn(n * p, n * p)
bbV = randn(n * p)
cc = randn(p * p, p * p)
dd = sym(randn(p, p))
def v_func_flat(S):
# a function from the manifold
# to ambient
csp = sym((cc @ S.P.reshape(-1)).reshape(p, p))
return fr_ambient((aaU @ S.U.reshape(-1) + bbU).reshape(m, p),
(aaV @ S.V.reshape(-1) + bbV).reshape(n,
p), csp + dd)
vv = v_func_flat(S) # vv is not horizontal
dlt = 1e-7
Snew = fr_point(S.U + dlt * xi.tU, S.V + dlt * xi.tV, S.P + dlt * xi.tP)
vnew = v_func_flat(Snew)
val = man.inner(S, vv)
valnew = man.inner(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))
# not equal bc vv is not horizontal:
nabla_xi_va = dv + man.g_inv(
S,
super(RealFixedRank, 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_geodesics():
from scipy.linalg import expm
alpha = randint(1, 10, 2) * .1
gamma = randint(1, 10, 2) * .1
beta = randint(1, 10, 2)[0] * .1
m = 4
n = 5
p = 3
man = RealFixedRank(m, n, p, alpha=alpha, beta=beta, gamma=gamma)
X = man.rand()
alf = alpha[1] / alpha[0]
gmm = gamma[1] / gamma[0]
def calc_Christoffel_Gamma(man, X, xi, eta):
dprj = man.D_proj(X, xi, eta)
proj_christoffel = man.proj_g_inv(X, man.christoffel_form(X, xi, eta))
return proj_christoffel - dprj
eta = man.randvec(X)
g1 = calc_Christoffel_Gamma(man, X, eta, eta)
g2 = man.christoffel_gamma(X, eta, eta)
print(man._vec(g1 - g2))
egrad = man._rand_ambient()
print(man.base_inner_ambient(g1, egrad))
print(man.rhess02_alt(X, eta, eta, egrad, 0))
print(man.rhess02(X, eta, eta, egrad, man.zerovec(X)))
t = 1
AU = X.U.T @ eta.tU
KU = eta.tU - X.U @ (X.U.T @ eta.tU)
Up, RU = np.linalg.qr(KU)
xU_mat = np.bmat([[2 * alf * AU, -RU.T], [RU, zeros((p, p))]])
Ut = np.bmat([X.U, Up]) @ expm(t*xU_mat)[:, :p] @ \
expm(t*(1-2*alf)*AU)
xU_d_mat = xU_mat[:, :p].copy()
xU_d_mat[:p, :] += (1 - 2 * alf) * AU
Udt = np.bmat([X.U, Up]) @ expm(t*xU_mat) @ xU_d_mat @\
expm(t*(1-2*alf)*AU)
xU_dd_mat = xU_mat @ xU_d_mat + xU_d_mat @ ((1 - 2 * alf) * AU)
Uddt = np.bmat([X.U, Up]) @ expm(t*xU_mat) @ xU_dd_mat @\
expm(t*(1-2*alf)*AU)
AV = X.V.T @ eta.tV
KV = eta.tV - X.V @ (X.V.T @ eta.tV)
Vp, RV = np.linalg.qr(KV)
xV_mat = np.bmat([[2 * gmm * AV, -RV.T], [RV, zeros((p, p))]])
Vt = np.bmat([X.V, Vp]) @ expm(t*xV_mat)[:, :p] @ \
expm(t*(1-2*gmm)*AV)
xV_d_mat = xV_mat[:, :p].copy()
xV_d_mat[:p, :] += (1 - 2 * gmm) * AV
Vdt = np.bmat([X.V, Vp]) @ expm(t*xV_mat) @ xV_d_mat @\
expm(t*(1-2*gmm)*AV)
xV_dd_mat = xV_mat @ xV_d_mat + xV_d_mat @ ((1 - 2 * gmm) * AV)
Vddt = np.bmat([X.V, Vp]) @ expm(t*xV_mat) @ xV_dd_mat @\
expm(t*(1-2*gmm)*AV)
sqrtP = X.evec @ np.diag(np.sqrt(X.evl)) @ X.evec.T
isqrtP = X.evec @ np.diag(1 / np.sqrt(X.evl)) @ X.evec.T
Pinn = t * isqrtP @ eta.tP @ isqrtP
ePinn = expm(Pinn)
Pt = sqrtP @ ePinn @ sqrtP
Pdt = eta.tP @ isqrtP @ ePinn @ sqrtP
Pddt = eta.tP @ isqrtP @ ePinn @ isqrtP @ eta.tP
Xt = fr_point(np.array(Ut), np.array(Vt), np.array(Pt))
Xdt = fr_ambient(np.array(Udt), np.array(Vdt), np.array(Pdt))
Xddt = fr_ambient(np.array(Uddt), np.array(Vddt), np.array(Pddt))
gcheck = Xddt + calc_Christoffel_Gamma(man, Xt, Xdt, Xdt)
print(man._vec(gcheck))
Xt1 = man.exp(X, t * eta)
print((Xt1.U - Xt.U))
print((Xt1.V - Xt.V))
print((Xt1.P - Xt.P))
def test_rhess_02():
alpha = randint(1, 10, 2) * .1
gamma = randint(1, 10, 2) * .1
beta = randint(1, 10, 2)[0] * .1
m = 4
n = 5
p = 3
man = RealFixedRank(m, n, p, alpha=alpha, beta=beta, gamma=gamma)
S = man.rand()
# simple function. Distance to a given matrix
# || S - A||_F^2 Basically SVD
A = randn(m, n)
def f(S):
diff = (A - S.U @ S.P @ S.V.T)
return trace(diff @ diff.T)
def df(S):
return fr_ambient(-2 * A @ S.V @ S.P, -2 * A.T @ S.U @ S.P,
2 * (S.P - S.U.T @ A @ S.V))
def ehess_vec(S, xi):
return fr_ambient(-2 * A @ (xi.tV @ S.P + S.V @ xi.tP),
-2 * A.T @ (xi.tU @ S.P + S.U @ xi.tP),
2 * (xi.tP - xi.tU.T @ A @ S.V - S.U.T @ A @ xi.tV))
def ehess_form(S, xi, eta):
ev = ehess_vec(S, xi)
return trace(ev.tU.T @ eta.tU) + trace(ev.tV.T @ eta.tV) +\
trace(ev.tP.T @ eta.tP)
xxi = man.randvec(S)
dlt = 1e-8
Snew = fr_point(S.U + dlt * xxi.tU, S.V + dlt * xxi.tV, S.P + dlt * xxi.tP)
d1 = (f(Snew) - f(S)) / dlt
d2 = df(S)
print(d1 - man.base_inner_ambient(d2, xxi))
dv1 = (df(Snew) - df(S)).scalar_mul(1 / dlt)
dv2 = ehess_vec(S, xxi)
print(man._vec(dv1 - dv2))
eeta = man.randvec(S)
d1 = man.base_inner_ambient((df(Snew) - df(S)), eeta) / dlt
ehess_val = ehess_form(S, xxi, eeta)
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.
mU1 = randn(m, m)
mV1 = randn(n, n)
m2 = randn(p, p)
m_p = randn(p * p, p * p)
def eta_field(Sin):
return man.proj(
S,
fr_ambient(mU1 @ (Sin.U - S.U) @ m2, mV1 @ (Sin.V - S.V) @ m2,
sym((m_p @ (Sin.P - S.P).reshape(-1)).reshape(
p, p)))) + 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(S, rhessvec, eta1)
print(man.inner(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(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 = fr_point(S.U + dlt * xi1.tU, S.V + dlt * xi1.tV, 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 num_deriv_amb(man, S, xi, func, dlt=1e-7):
Snew = fr_point(S.U + dlt * xi.tU, S.V + dlt * xi.tV, S.P + dlt * xi.tP)
return (func(Snew) - func(S)).scalar_mul(1 / dlt)
def test_chris_vectorfields():
# now test that it works on embedded metrics
# we test that D_xi (eta g eta) = 2(eta g nabla_xi eta)
alpha = randint(1, 10, 2) * .1
gamma = randint(1, 10, 2) * .1
beta = randint(1, 10, 2)[0] * .1
m = 4
n = 5
p = 3
man = RealFixedRank(m, n, p, alpha=alpha, beta=beta, gamma=gamma)
S0 = man.rand()
aaU = randn(m * p, m * p)
intcU = randn(m * p)
aaV = randn(n * p, n * p)
intcV = randn(n * p)
cc = randn(p * p, p * p)
p_intc = sym(randn(p, p))
inct_xi = man._rand_ambient()
aa_xiU = randn(m * p, m * p)
aa_xiV = randn(n * p, n * p)
cc_xi = randn(p * p, p * p)
def v_func(S):
# a function from the manifold
# to ambient
csp = sym((cc @ (S.P - S0.P).reshape(-1)).reshape(p, p))
return man.proj(
S,
fr_ambient((aaU @ (S.U - S0.U).reshape(-1) + intcU).reshape(m, p),
(aaV @ (S.V - S0.V).reshape(-1) + intcV).reshape(n, p),
csp + p_intc))
SS = fr_point(S0.U, S0.V, S0.P)
xi = man.proj(SS, inct_xi)
nabla_xi_v, dv, cxv = calc_covar_numeric(man, SS, xi, v_func)
def xi_func(S):
csp_xi = sym((cc_xi @ (S.P - S0.P).reshape(-1)).reshape(p, p))
xi_amb = fr_ambient((aa_xiU @ (S.U - S0.U).reshape(-1) +
inct_xi.tU.reshape(-1)).reshape(m, p),
(aa_xiV @ (S.V - S0.V).reshape(-1) +
inct_xi.tV.reshape(-1)).reshape(n, p),
csp_xi + inct_xi.tP)
return man.proj(S, xi_amb)
vv = v_func(SS)
nabla_v_xi, dxi, cxxi = calc_covar_numeric(man, SS, vv, xi_func)
diff = nabla_xi_v - nabla_v_xi
print(diff.tU, diff.tV, diff.tP)
# now do Lie bracket:
dlt = 1e-7
SnewXi = fr_point(SS.U + dlt * xi.tU, SS.V + dlt * xi.tV,
SS.P + dlt * xi.tP)
Snewvv = fr_point(SS.U + dlt * vv.tU, SS.V + dlt * vv.tV,
SS.P + dlt * vv.tP)
vnewxi = v_func(SnewXi)
xnewv = xi_func(Snewvv)
dxiv = (vnewxi - vv).scalar_mul(1 / dlt)
dvxi = (xnewv - xi).scalar_mul(1 / dlt)
diff2 = man.proj(SS, dxiv - dvxi)
print(check_zero(man._vec(diff) - man._vec(diff2)))
def test_all_projections():
alpha = randint(1, 10, 2) * .1
gamma = randint(1, 10, 2) * .1
beta = randint(1, 10, 1)[0] * .02
m = 4
n = 5
d = 3
man = RealFixedRank(m, n, d, alpha=alpha, beta=beta, gamma=gamma)
X = man.rand()
test_inner(man, X)
test_J(man, X)
# now check metric, Jst etc
# check Jst: vectorize the operator J then compare Jst with jmat.T
# test projection
test_projection(man, X)
# now diff projection
for i in range(1):
e = man._rand_ambient()
X1 = man.rand()
xi = man.randvec(X1)
dlt = 1e-7
X2 = fr_point(X1.U + dlt * xi.tU, X1.V + dlt * xi.tV,
X1.P + dlt * xi.tP)
# S = psd_point(S1.Y, S1.P)
"""
Dp, Dm = calc_D(man, X1, e)
Dp2, Dm2 = calc_D(man, X2, e)
omg = e
al1 = man.alpha[1]
gm1 = man.gamma[1]
U, V, P, Piv = (X1.U, X1.V, X1.P, X1.Pinv)
agi = 1/(al1+gm1)
DxiLDp = agi*(xi.tP @ Dp @ Piv + Piv @ Dp @ xi.tP -
P @ Dp @ Piv @ xi.tP @ Piv -
Piv @ xi.tP @ Piv @ Dp @ P)
def LP(X, Dp):
return (1/man.beta - 2*agi)*Dp +\
agi*(X.Pinv @Dp @ X.P + X.P@ Dp @ X.Pinv)
print((LP(X2, Dp) - LP(X1, Dp))/dlt)
ddin = agi*(
al1*([email protected]@P - [email protected]@omg.tU +
U.T @[email protected] - [email protected]@omg.tU) +
gm1*([email protected]@P - [email protected]@omg.tV +
V.T @[email protected] - [email protected]@omg.tV)) - DxiLDp
Ddp = extended_lyapunov(1/man.beta, agi, P, sym(ddin), X1.evl, X1.evec)
Ddm = agi*asym([email protected] - [email protected])
print(check_zero(Ddm - (Dm2-Dm)/dlt))
print(check_zero(Ddp - (Dp2-Dp)/dlt))
"""
d1 = (man.proj(X2, e) - man.proj(X1, e)).scalar_mul(1 / dlt)
d2 = man.D_proj(X1, xi, e)
print(check_zero(man._vec(d1 - d2)))
for i in range(20):
Uran = man._rand_ambient()
Upr = man.proj(X, man.g_inv(X, Uran))
Upr2 = man.proj_g_inv(X, Uran)
print(check_zero(man._vec(Upr) - man._vec(Upr2)))
# derives metrics
for ii in range(10):
X1 = man.rand()
xi = man.randvec(X1)
omg1 = man._rand_ambient()
omg2 = man._rand_ambient()
dlt = 1e-7
X2 = fr_point(X1.U + dlt * xi.tU, X1.V + dlt * xi.tV,
X1.P + dlt * xi.tP)
p1 = man.inner(X1, omg1, omg2)
p2 = man.inner(X2, omg1, omg2)
der1 = (p2 - p1) / dlt
der2 = man.base_inner_ambient(man.D_g(X1, xi, omg2), omg1)
print(der1 - der2)
# cross term for christofel
for i in range(10):
X1 = man.rand()
xi = man.randvec(X1)
eta1 = man.randvec(X1)
eta2 = man.randvec(X1)
dr1 = man.D_g(X1, xi, eta1)
x12 = man.contract_D_g(X1, 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 base 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)
v5 = man.base_inner_ambient(man.contract_D_g(S1, eta1, eta2), xi)
print(v1, 0.5 * (v2 + v3 - v4), v1 - 0.5 * (v2 + v3 - v4))