def test_vectorize(): from ManNullRange.manifolds.tools import cvech, cunvech, cvecah, cunvecah p = 10 mat = crandn(p, p) mat += mat.T.conjugate() v = cvech(mat) mat2 = cunvech(v) print(check_zero(mat - mat2)) # check inner product: for i in range(p * p): v = zeros(p * p) v[i] = 1 h = cunvech(v) assert (np.abs(trace(h @ h.T.conjugate()).real - 1) < 1e-10) # now do skew mat = crandn(p, p) mat -= mat.T.conjugate() v = cvecah(mat) mat2 = cunvecah(v) print(check_zero(mat - mat2)) for i in range(p * p): v = zeros(p * p) v[i] = 1 h = cunvecah(v) assert (np.abs(trace(h @ h.T.conjugate()).real - 1) < 1e-10)
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 n = 5 d = 3 man = ComplexStiefel(n, d, alpha=alpha) Y = man.rand() xi = man.randvec(Y) aa = crandn(n * d, n * d) bb = crandn(n * d) def v_func_flat(Y): return (aa @ Y.reshape(-1) + bb).reshape(n, d) vv = v_func_flat(Y) dlt = 1e-7 Ynew = Y + dlt * xi vnew = v_func_flat(Ynew) val = man.inner(Y, vv, vv) valnew = man.inner(Ynew, vnew, vnew) d1 = (valnew - val) / dlt dv = (vnew - vv) / dlt nabla_xi_v = dv + man.g_inv(Y, man.christoffel_form(Y, xi, vv)) d2 = man.inner(Y, vv, nabla_xi_v) print(d1) print(2 * d2)
def optim_test(): m, n, p = (1000, 500, 50) # m, n, p = (10, 3, 2) # simple function. Distance to a given matrix # || S - A||_F^2 U0, _ = la.qr(crandn(m, p)) V0, _ = la.qr(crandn(n, p)) P0 = np.diag(randint(1, 1000, p)*.001) A0 = U0 @ P0 @ V0.T.conj() A = crandn(m, n)*1e-2 + A0 alpha = np.array([1, 1]) gamma = np.array([1, 1]) print("alpha %s" % str(alpha)) beta = alpha[1] * .1 man = ComplexFixedRank(m, n, p, alpha=alpha, beta=beta, gamma=gamma) XInit = man.rand() opt_pre = solve_dist_with_man(man, A, X0=XInit, maxiter=20) beta = alpha[1] * 1 man = ComplexFixedRank(m, n, p, alpha=alpha, beta=beta, gamma=gamma) opt_mid = solve_dist_with_man(man, A, X0=opt_pre, maxiter=20) # opt_mid = opt_pre beta = alpha[1] * 30 man = ComplexFixedRank(m, n, p, alpha=alpha, beta=beta, gamma=gamma) opt = solve_dist_with_man(man, A, X0=opt_mid, maxiter=50) opt_mat = opt.U @ opt.P @ opt.V.T.conj() if False: print(A0) print(opt_mat) print(np.max(np.abs(A0-opt_mat)))
def optim_test(): n, d = (1000, 50) # n, d = (10, 3) # simple function. Distance to a given matrix # || S - A||_F^2 Y0, _ = np.linalg.qr(crandn(n, d)) P0 = np.diag(randint(1, 1000, d) * .001) A00 = Y0 @ P0 @ Y0.T.conjugate() A0 = hsym(A00) A = (hsym(crandn(n, n)) * 1e-2 + A0) alpha = np.array([1, 1]) print("alpha %s" % str(alpha)) beta = alpha[1] * .1 man = ComplexPositiveSemidefinite(n, d, alpha=alpha, beta=beta) XInit = man.rand() opt_pre = solve_dist_with_man(man, A, X0=XInit, maxiter=20) beta = alpha[1] * 1 man = ComplexPositiveSemidefinite(n, d, alpha=alpha, beta=beta) opt_mid = solve_dist_with_man(man, A, X0=opt_pre, maxiter=20) # opt_mid = opt_pre beta = alpha[1] * 30 man = ComplexPositiveSemidefinite(n, d, alpha=alpha, beta=beta) opt = solve_dist_with_man(man, A, X0=opt_mid, maxiter=500) opt_mat = opt.Y @ opt.P @ opt.Y.T.conjugate() if False: print(A0) print(opt_mat) print(np.max(np.abs(A0 - opt_mat)))
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) """ dvec = np.array([10, 3, 2, 3]) p = dvec.shape[0] - 1 alpha = randint(1, 10, (p, p + 1)) * .1 man = ComplexFlag(dvec, alpha=alpha) Y = man.rand() n = man.n d = man.d xi = man.randvec(Y) aa = crandn(n * d, n * d) bb = crandn(n * d) def v_func_flat(Y): return (aa @ Y.reshape(-1) + bb).reshape(n, d) vv = v_func_flat(Y) dlt = 1e-7 Ynew = Y + dlt * xi vnew = v_func_flat(Ynew) val = man.inner(Y, vv, vv) valnew = man.inner(Ynew, vnew, vnew) d1 = (valnew - val) / dlt dv = (vnew - vv) / dlt nabla_xi_v = dv + man.g_inv(Y, man.christoffel_form(Y, xi, vv)) d2 = man.inner(Y, vv, nabla_xi_v) print(d1) print(2 * d2)
def test_covariance_deriv(): # now test full: # do covariant derivatives # check that it works, preseving everything n, d = (5, 3) alpha = randint(1, 10, 2) * .1 man = ComplexStiefel(n, d, alpha=alpha) Y = man.rand() slp = crandn(n * d) aa = crandn(n * d, n * d) def omg_func(Y): return (aa @ Y.reshape(-1) + slp).reshape(n, d) xi = man.randvec(Y) egrad = omg_func(Y) ehess = (aa @ xi.reshape(-1)).reshape(n, d) val1 = man.ehess2rhess(Y, egrad, ehess, xi) if False: val1a = man.ehess2rhess_alt(Y, egrad, ehess, xi) print(check_zero(val1 - val1a)) def rgrad_func(W): return man.proj_g_inv(W, omg_func(W)) if False: first = ehess a = man.J(Y, man.g_inv(Y, egrad)) rgrad = man.proj_g_inv(Y, egrad) second = -man.D_g(Y, xi, man.g_inv(Y, egrad)) aout = man.solve_J_g_inv_Jst(Y, a) third = -man.proj(Y, man.D_g_inv_Jst(Y, xi, aout)) fourth = man.christoffel_form(Y, xi, rgrad) val1a = man.proj_g_inv(Y, first + second + fourth) + third d_xi_rgrad = num_deriv(man, Y, xi, rgrad_func) rgrad = man.proj_g_inv(Y, egrad) fourth = man.christoffel_form(Y, xi, rgrad) val1b = man.proj(Y, d_xi_rgrad) + man.proj_g_inv(Y, fourth) print(check_zero(val1 - val1b)) # nabla_v_xi, dxi, cxxi val2a, _, _ = calc_covar_numeric(man, Y, xi, omg_func) val2, _, _ = calc_covar_numeric(man, Y, xi, rgrad_func) # val2_p = project(prj, val2) val2_p = man.proj(Y, val2) # print(val1) # print(val2_p) print(val1 - val2_p)
def testN(man, X): m, n, p = (man.m, man.n, man.p) B = crandn(m-p, p) C = crandn(n-p, p) D = crandn(p, p) ee = N(man, X, B, C, D) print(check_zero(stU(X, ee))) print(check_zero(stV(X, ee))) print(check_zero(symP(X, ee))) print(check_zero(Hz(man, X, ee))) nmat = make_N_mat(man, X) ee2 = man._unvec(nmat @ np.concatenate( [cvec(B), cvec(C), cvec(D)])) print(check_zero(man._vec(ee - ee2)))
def testNTgN(man, X): m, n, p = (man.m, man.n, man.p) B0 = crandn(m-p, p) C0 = crandn(n-p, p) D0 = crandn(p, p) out1 = NTgN @ np.concatenate( [cvec(B0), cvec(C0), cvec(D0)]) out2a = NTgN_opt(X, B0, C0, D0) out2 = np.concatenate( [cvec(out2a[0]), cvec(out2a[1]), cvec(out2a[2])]) print(check_zero(out1-out2)) out2b = solveNTgN(X, *out2a) print(check_zero(out2b[2]-D0)) print(check_zero(out2b[1]-C0)) print(check_zero(out2b[0]-B0))
def rand_vertical(): oo = crandn(man.p, man.p) oo = oo - oo.T.conj() return fr_ambient( X.U @ oo, X.V @ oo, -oo @ X.P + X.P @oo)
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_chris_vectorfields(): # now test that it works on embedded metrics # we test that D_xi (eta g eta) = 2(eta g nabla_xi eta) dvec = np.array([10, 3, 2, 3]) p = dvec.shape[0] - 1 alpha = randint(1, 10, (p, p + 1)) * .1 man = ComplexFlag(dvec, alpha=alpha) n = man.n d = man.d slp = crandn(n * d) Y0 = man.rand() slpxi = crandn(n * d) aa = crandn(n * d, n * d) aaxi = crandn(n * d, n * d) def v_func(Y): return man.proj(Y, (aa @ (Y - Y0).reshape(-1) + slp).reshape(n, d)) YY = Y0.copy() xi = man.proj(YY, slpxi.reshape(n, d)) nabla_xi_v, dv, cxv = calc_covar_numeric(man, YY, xi, v_func) def xi_func(Y): return man.proj(Y, (aaxi @ (Y - Y0).reshape(-1) + slpxi).reshape(n, d)) vv = v_func(YY) nabla_v_xi, dxi, cxxi = calc_covar_numeric(man, YY, vv, xi_func) diff = nabla_xi_v - nabla_v_xi # print(diff) # now do Lie bracket: dlt = 1e-7 YnewXi = YY + dlt * xi Ynewvv = YY + dlt * vv vnewxi = v_func(YnewXi) xnewv = xi_func(Ynewvv) dxiv = (vnewxi - vv) / dlt dvxi = (xnewv - xi) / dlt diff2 = man.proj(YY, dxiv - dvxi) print(check_zero(diff - diff2))
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 = ComplexFixedRank(m, n, p, alpha=alpha, beta=beta, gamma=gamma) S = man.rand() xi = man.randvec(S) aaU = crandn(m*p, m*p) bbU = crandn(m*p) aaV = crandn(n*p, n*p) bbV = crandn(n*p) cc = crandn(p*p, p*p) dd = hsym(crandn(p, p)) def v_func_flat(S): # a function from the manifold # to ambient csp = hsym((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(ComplexFixedRank, 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_chris_vectorfields(): # now test that it works on embedded metrics # we test that D_xi (eta g eta) = 2(eta g nabla_xi eta) n, d = (20, 3) alpha = randint(1, 10, 2) * .1 beta = randint(1, 10, 1)[0] * .1 man = ComplexPositiveSemidefinite(n, d, alpha=alpha, beta=beta) S0 = man.rand() aa = crandn(n * d, n * d) intc = crandn(n * d) cc = crandn(d * d, d * d) p_intc = hsym(crandn(d, d)) inct_xi = man._rand_ambient() aa_xi = crandn(n * d, n * d) cc_xi = crandn(d * d, d * d) def v_func(S): # a function from the manifold # to ambient csp = hsym((cc @ (S.P - S0.P).reshape(-1)).reshape(d, d)) return man.proj( S, psd_ambient((aa @ (S.Y - S0.Y).reshape(-1) + intc).reshape(n, d), csp + p_intc)) SS = psd_point(S0.Y, 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 = hsym((cc_xi @ (S.P - S0.P).reshape(-1)).reshape(d, d)) xi_amb = psd_ambient((aa_xi @ (S.Y - S0.Y).reshape(-1) + inct_xi.tY.reshape(-1)).reshape(n, d), 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.tY, diff.tP) # now do Lie bracket: dlt = 1e-7 SnewXi = psd_point(SS.Y + dlt * xi.tY, SS.P + dlt * xi.tP) Snewvv = psd_point(SS.Y + dlt * vv.tY, 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_lyapunov(): 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) S = man.rand() P = S.P B = crandn(d, d) alpha1 = alpha[1] def L(X, P): Piv = la.inv(P) return (alpha1 - 2 * beta) * X + beta * (P @ X @ Piv + Piv @ X @ P) X = extended_lyapunov(alpha1, beta, P, B) # L(X, P) print(check_zero(B - L(X, P)))
def test_rhess_02(): n, d = (5, 3) alpha = randint(1, 10, 2) * .1 man = ComplexStiefel(n, d, alpha=alpha) Y = man.rand() UU = make_sym_pos(n) def f(Y): return rtrace(UU @ Y @ Y.T.conj()) def df(Y): return 2 * UU @ Y def ehess_form(Y, xi, eta): return 2 * rtrace(UU @ xi @ eta.T.conj()) def ehess_vec(Y, xi): return 2 * UU @ xi xxi = crandn(n, d) dlt = 1e-8 Ynew = Y + dlt * xxi d1 = (f(Ynew) - f(Y)) / dlt d2 = df(Y) print(d1 - rtrace(d2 @ xxi.T.conj())) eeta = crandn(n, d) d1 = rtrace((df(Ynew) - df(Y)) @ eeta.T.conj()) / dlt ehess_val = ehess_form(Y, xxi, eeta) dv2 = ehess_vec(Y, xxi) print(rtrace(dv2 @ eeta.T.conj())) 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) def eta_field(Yin): return m1 @ (Yin - Y) @ m2 + eeta # xietaf: should go to ehess(xi, eta) + df(Y) @ etafield) xietaf = rtrace( df(Ynew) @ eta_field(Ynew).T.conj() - df(Y) @ eta_field(Y).T.conj()) / dlt # appy eta_func to f: should go to tr(m1 @ xxi @ m2 @ df(Y).T.conj()) Dxietaf = rtrace((eta_field(Ynew) - eta_field(Y)) @ df(Y).T.conj()) / 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(Y, xxi) eta1 = man.proj(Y, eeta) egvec = df(Y) ehvec = ehess_vec(Y, xi1) rhessvec = man.ehess2rhess(Y, egvec, ehvec, xi1) # check it numerically: def rgrad_func(Y): return man.proj_g_inv(Y, df(Y)) val2, _, _ = calc_covar_numeric(man, Y, xi1, rgrad_func) val2_p = man.proj(Y, val2) # print(rhessvec) # print(val2_p) print(check_zero(rhessvec - val2_p)) rhessval = man.inner(Y, rhessvec, eta1) print(man.inner(Y, val2, eta1)) print(rhessval) # check symmetric: ehvec_e = ehess_vec(Y, eta1) rhessvec_e = man.ehess2rhess(Y, egvec, ehvec_e, eta1) rhessval_e = man.inner(Y, rhessvec_e, xi1) rhessval_e1 = man.rhess02(Y, xi1, eta1, egvec, ehvec) rhessval_e2 = man.rhess02_alt(Y, xi1, eta1, egvec, rtrace(ehvec @ eta1.T.conj())) print(rhessval_e, rhessval_e1, rhessval_e2) print('rhessval_e %f ' % 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(Y): return man.proj(Y, eta_field(Y)) print(check_zero(eta1 - eta_proj(Y))) e1 = man.inner(Y, man.proj_g_inv(Y, df(Y)), eta_proj(Y)) e1a = rtrace(df(Y) @ eta_proj(Y).T.conj()) print(e1, e1a, e1 - e1a) Ynew = Y + xi1 * dlt e2 = man.inner(Ynew, man.proj_g_inv(Ynew, df(Ynew)), eta_proj(Ynew)) e2a = rtrace(df(Ynew) @ eta_proj(Ynew).T.conj()) print(e2, e2a, e2 - e2a) first = (e2 - e1) / dlt first1 = rtrace( df(Ynew) @ eta_proj(Ynew).T.conj() - df(Y) @ eta_proj(Y).T.conj()) / dlt print(first - first1) val3, _, _ = calc_covar_numeric(man, Y, xi1, eta_proj) second = man.inner(Y, man.proj_g_inv(Y, df(Y)), man.proj(Y, val3)) second2 = man.inner(Y, man.proj_g_inv(Y, df(Y)), val3) print(second, second2, second - second2) print('same as rhess_val %f' % (first - second))
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_covariance_deriv(): # now test full: # do covariant derivatives # check that it works, preseving everything n, d = (5, 3) alpha = randint(1, 10, 2) * .1 beta = randint(1, 10, 2)[0] * .01 man = ComplexPositiveSemidefinite(n, d, alpha=alpha, beta=beta) S = man.rand() aa = crandn(n * d, n * d) cc = crandn(d * d, d * d) icpt = man._rand_ambient() def omg_func(S): csp = hsym((cc @ S.P.reshape(-1)).reshape(d, d)) return psd_ambient( (aa @ S.Y.reshape(-1) + icpt.tY.reshape(-1)).reshape(n, d), csp + icpt.tP) xi = man.randvec(S) egrad = omg_func(S) ecsp = hsym((cc @ xi.tP.reshape(-1)).reshape(d, d)) ehess = psd_ambient((aa @ xi.tY.reshape(-1)).reshape(n, d), ecsp) val1 = man.ehess2rhess(S, egrad, ehess, xi) def rgrad_func(W): return man.proj_g_inv(W, omg_func(W)) if False: first = ehess a = man.J_g_inv(S, egrad) rgrad = man.proj_g_inv(S, egrad) second = man.D_g(S, xi, man.g_inv(S, egrad)).scalar_mul(-1) aout = man.solve_J_g_inv_Jst(S, a) third = man.proj(S, man.D_g_inv_Jst(S, xi, aout)).scalar_mul(-1) fourth = man.christoffel_form(S, xi, rgrad) val1a1 = man.proj_g_inv(S, first + second + fourth) + third print(check_zero(man._vec(val1 - val1a1))) elif True: d_xi_rgrad = num_deriv_amb(man, S, xi, rgrad_func) rgrad = man.proj_g_inv(S, egrad) fourth = man.christoffel_form(S, xi, rgrad) val1a = man.proj(S, d_xi_rgrad) + man.proj_g_inv(S, fourth) print(check_zero(man._vec(val1 - val1a))) # nabla_v_xi, dxi, cxxi val2a, _, _ = calc_covar_numeric(man, S, xi, omg_func) val2, _, _ = calc_covar_numeric(man, S, xi, rgrad_func) # val2_p = project(prj, val2) val2_p = man.proj(S, val2) # print(val1) # print(val2_p) print(check_zero(man._vec(val1) - man._vec(val2_p))) if True: H = xi valrangeA_ = ehess + man.g(S, man.D_proj( S, H, man.g_inv(S, egrad))) - man.D_g( S, H, man.g_inv(S, egrad)) +\ man.christoffel_form(S, H, man.proj_g_inv(S, egrad)) valrangeB = man.proj_g_inv(S, valrangeA_) valrange = man.ehess2rhess_alt(S, egrad, ehess, xi) print(check_zero(man._vec(valrange) - man._vec(val2_p))) print(check_zero(man._vec(valrange) - man._vec(val1))) print(check_zero(man._vec(valrange) - man._vec(valrangeB)))
def test_rhess_02(): np.random.seed(0) dvec = np.array([10, 3, 2, 3]) p = dvec.shape[0] - 1 alpha = randint(1, 10, (p, p + 1)) * .1 man = ComplexFlag(dvec, alpha=alpha) n = man.n d = man.d Y = man.rand() UU = {} p = alpha.shape[0] VV = {} gidx = man._g_idx for rr in range(p): UU[rr] = make_sym_pos(n) VV[rr] = crandn(n, dvec[rr + 1]) def f(Y): ss = 0 for rr in range(p): br, er = gidx[rr + 1] wr = Y[:, br:er] ss += trace(UU[rr] @ wr @ wr.T.conjugate()).real return ss def df(W): ret = np.zeros_like(W) for rr in range(p): br, er = gidx[rr + 1] wr = W[:, br:er] ret[:, br:er] += 2 * UU[rr] @ wr return ret def ehess_form(W, xi, eta): ss = 0 for rr in range(p): br, er = gidx[rr + 1] ss += 2 * trace( UU[rr] @ xi[:, br:er] @ eta[:, br:er].T.conjugate()).real return ss def ehess_vec(W, xi): ret = np.zeros_like(W) for rr in range(p): br, er = gidx[rr + 1] ret[:, br:er] += 2 * UU[rr] @ xi[:, br:er] return ret xxi = crandn(n, d) dlt = 1e-8 Ynew = Y + dlt * xxi d1 = (f(Ynew) - f(Y)) / dlt d2 = df(Y) print(d1 - trace(d2 @ xxi.T.conjugate()).real) eeta = crandn(n, d) d1 = trace((df(Ynew) - df(Y)) @ eeta.T.conjugate()).real / dlt ehess_val = ehess_form(Y, xxi, eeta) # ehess_val2 = ehess_form(Y, eeta, xxi) dv2 = ehess_vec(Y, xxi) print(trace(dv2 @ eeta.T.conjugate()).real) 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) def eta_field(Yin): return m1 @ (Yin - Y) @ m2 + eeta # xietaf: should go to ehess(xi, eta) + df(Y) @ etafield) xietaf = trace( df(Ynew) @ eta_field(Ynew).T.conjugate() - df(Y) @ eta_field(Y).T.conjugate()).real / dlt # appy eta_func to f: should go to tr(m1 @ xxi @ m2 @ df(Y).T.conjugate()) Dxietaf = trace( (eta_field(Ynew) - eta_field(Y)) @ df(Y).T.conjugate()).real / 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(Y, xxi) eta1 = man.proj(Y, eeta) egvec = df(Y) ehvec = ehess_vec(Y, xi1) rhessvec = man.ehess2rhess(Y, egvec, ehvec, xi1) # check it numerically: def rgrad_func(Y): return man.proj_g_inv(Y, df(Y)) val2, _, _ = calc_covar_numeric(man, Y, xi1, rgrad_func) val2_p = man.proj(Y, val2) # print(rhessvec) # print(val2_p) print(check_zero(rhessvec - val2_p)) rhessval = man.inner(Y, rhessvec, eta1) print(man.inner(Y, val2, eta1)) print(rhessval) # check symmetric: ehvec_e = ehess_vec(Y, eta1) ehess_valp = ehess_form(Y, xi1, eta1) rhessvec_e = man.ehess2rhess(Y, egvec, ehvec_e, eta1) rhessval_e = man.inner(Y, rhessvec_e, xi1) rhessval_e1 = man.rhess02(Y, xi1, eta1, egvec, ehess_valp) # rhessval_e2 = man.rhess02_alt(Y, xi1, eta1, egvec, # trace([email protected]()).real) # print(rhessval_e, rhessval_e1, rhessval_e2) print(rhessval_e, rhessval_e1, rhessval_e - rhessval_e1) print('rhessval_e %f ' % 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(Y): return man.proj(Y, eta_field(Y)) print(check_zero(eta1 - eta_proj(Y))) e1 = man.inner(Y, man.proj_g_inv(Y, df(Y)), eta_proj(Y)) e1a = trace(df(Y) @ eta_proj(Y).T.conjugate()).real print(e1, e1a, e1 - e1a) Ynew = Y + xi1 * dlt e2 = man.inner(Ynew, man.proj_g_inv(Ynew, df(Ynew)), eta_proj(Ynew)) e2a = trace(df(Ynew) @ eta_proj(Ynew).T.conjugate()).real print(e2, e2a, e2 - e2a) first = (e2 - e1) / dlt first1 = trace( df(Ynew) @ eta_proj(Ynew).T.conjugate() - df(Y) @ eta_proj(Y).T.conjugate()).real / dlt print(first - first1) val3, _, _ = calc_covar_numeric(man, Y, xi1, eta_proj) second = man.inner(Y, man.proj_g_inv(Y, df(Y)), man.proj(Y, val3)) second2 = man.inner(Y, man.proj_g_inv(Y, df(Y)), val3) print(second, second2, second - second2) print('same as rhess_val %f' % (first - second))
def test_geodesics(): from scipy.linalg import expm alpha = np.random.randint(1, 10, (2)) * .1 # alpha = np.array([1, .5]) m, d = (5, 3) man = ComplexStiefel(m, d, alpha=alpha) Y = man.rand() alf = alpha[1] / alpha[0] def calc_gamma(man, Y, eta): etaxiy = 2 * eta @ (eta.T.conj() @ Y) egcoef = Y @ (eta.T.conj() @ eta) ft = 1 - alf egcoef += ft * (etaxiy - Y @ (Y.T.conj() @ etaxiy)) return egcoef eta = man.randvec(Y) g1 = calc_gamma(man, Y, eta) g2 = man.christoffel_gamma(Y, eta, eta) print(g1 - g2) egrad = crandn(m, d) print(rtrace(g1 @ egrad.T.conj())) print(man.rhess02_alt(Y, eta, eta, egrad, 0)) # try to see if the solution is good: A = Y.T.conj() @ eta S0 = eta.T.conj() @ eta e_mat = np.bmat([[(2 * alf - 1) * A, -S0 - 2 * (1 - alf) * A @ A], [np.eye(d), A]]) init_c = np.bmat([Y, eta]) def ff(t): v1 = init_c @ expm(t * e_mat) v2 = expm(t * (1 - 2 * alf) * A) return v1[:, :d] @ v2, v1[:, d:] @ v2, None t = 100 dlt = 1e-8 fval, fd, fdd = ff(t) fval1, fd1, fdd1 = ff(t + dlt) fval2, fd2, fdd2 = ff(t - dlt) ffdot = (fval1 - fval) / dlt print(check_zero(ffdot - fd)) ffddot_0 = (fval1 - 2 * fval + fval2) / (dlt * dlt) ffddot = (fd1 - fd) / dlt print(ffddot_0) print(ffddot) print(ffddot + calc_gamma(man, fval, ffdot)) # second solution: K = eta - Y @ (Y.T.conj() @ eta) Yp, R = np.linalg.qr(K) x_mat = np.bmat([[2 * alf * A, -R.T.conj()], [R, zeros((d, d))]]) Yt = np.bmat([Y, Yp]) @ expm(t*x_mat)[:, :d] @ \ expm(t*(1-2*alf)*A) x_d_mat = x_mat[:, :d].copy() x_d_mat[:d, :] += (1 - 2 * alf) * A Ydt = np.bmat([Y, Yp]) @ expm(t*x_mat) @ x_d_mat @\ expm(t*(1-2*alf)*A) x_dd_mat = x_mat @ x_d_mat + x_d_mat @ ((1 - 2 * alf) * A) Yddt = np.bmat([Y, Yp]) @ expm(t*x_mat) @ x_dd_mat @\ expm(t*(1-2*alf)*A) print(Yddt + calc_gamma(man, Yt, Ydt)) print(man.exp(Y, t * eta) - Yt)
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 = ComplexFixedRank(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 = crandn(m, n) def f(S): diff = (A - S.U @ S.P @ S.V.T.conj()) return rtrace(diff @ diff.T.conj()) def df(S): return fr_ambient(-2*A @ S.V @ S.P, -2*A.T.conj() @ S.U @S.P, 2*(S.P-S.U.T.conj() @ A @ S.V)) def ehess_vec(S, xi): return fr_ambient(-2*A @ (xi.tV @ S.P + S.V @ xi.tP), -2*A.T.conj() @ (xi.tU @S.P + [email protected]), 2*(xi.tP - xi.tU.T.conj()@[email protected] - S.U.T.conj()@[email protected])) def ehess_form(S, xi, eta): ev = ehess_vec(S, xi) return rtrace(ev.tU.T.conj() @ eta.tU) +\ rtrace(ev.tV.T.conj() @ eta.tV) +\ rtrace(ev.tP.T.conj() @ 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 = crandn(m, m) mV1 = crandn(n, n) m2 = crandn(p, p) m_p = crandn(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, hsym((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.conj()) 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 test_covariance_deriv(): # now test full: # do covariant derivatives 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 = ComplexFixedRank(m, n, p, alpha=alpha, beta=beta, gamma=gamma) S = man.rand() aaU = crandn(m*p, m*p) aaV = crandn(n*p, n*p) cc = crandn(p*p, p*p) icpt = man._rand_ambient() def omg_func(S): csp = hsym((cc @ S.P.reshape(-1)).reshape(p, p)) return fr_ambient( (aaU @ S.U.reshape(-1) + icpt.tU.reshape(-1)).reshape(m, p), (aaV @ S.V.reshape(-1) + icpt.tV.reshape(-1)).reshape(n, p), csp + icpt.tP) xi = man.randvec(S) egrad = omg_func(S) ecsp = hsym((cc @ xi.tP.reshape(-1)).reshape(p, p)) ehess = fr_ambient( (aaU @ xi.tU.reshape(-1)).reshape(m, p), (aaV @ xi.tV.reshape(-1)).reshape(n, p), ecsp) val1 = man.ehess2rhess(S, egrad, ehess, xi) def rgrad_func(W): return man.proj_g_inv(W, omg_func(W)) if False: first = ehess a = man.J_g_inv(S, egrad) rgrad = man.proj_g_inv(S, egrad) second = man.D_g( S, xi, man.g_inv(S, egrad)).scalar_mul(-1) aout = man.solve_J_g_inv_Jst(S, a) third = man.proj(S, man.D_g_inv_Jst(S, xi, aout)).scalar_mul(-1) fourth = man.christoffel_form(S, xi, rgrad) val1a1 = man.proj_g_inv(S, first + second + fourth) + third print(check_zero(man._vec(val1-val1a1))) elif True: d_xi_rgrad = num_deriv_amb(man, S, xi, rgrad_func) rgrad = man.proj_g_inv(S, egrad) fourth = man.christoffel_form(S, xi, rgrad) val1a = man.proj(S, d_xi_rgrad) + man.proj_g_inv(S, fourth) print(check_zero(man._vec(val1-val1a))) # nabla_v_xi, dxi, cxxi val2a, _, _ = calc_covar_numeric(man, S, xi, omg_func) val2, _, _ = calc_covar_numeric(man, S, xi, rgrad_func) # val2_p = project(prj, val2) val2_p = man.proj(S, val2) # print(val1) # print(val2_p) print(check_zero(man._vec(val1)-man._vec(val2_p))) if True: H = xi valrangeA_ = ehess + man.g(S, man.D_proj( S, H, man.g_inv(S, egrad))) - man.D_g( S, H, man.g_inv(S, egrad)) +\ man.christoffel_form(S, H, man.proj_g_inv(S, egrad)) valrangeB = man.proj_g_inv(S, valrangeA_) valrange = man.ehess2rhess(S, egrad, ehess, xi) print(check_zero(man._vec(valrange)-man._vec(val2_p))) print(check_zero(man._vec(valrange)-man._vec(val1))) print(check_zero(man._vec(valrange)-man._vec(valrangeB)))
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 = ComplexFixedRank(m, n, p, alpha=alpha, beta=beta, gamma=gamma) S0 = man.rand() aaU = crandn(m*p, m*p) intcU = crandn(m*p) aaV = crandn(n*p, n*p) intcV = crandn(n*p) cc = crandn(p*p, p*p) p_intc = hsym(crandn(p, p)) inct_xi = man._rand_ambient() aa_xiU = crandn(m*p, m*p) aa_xiV = crandn(n*p, n*p) cc_xi = crandn(p*p, p*p) def v_func(S): # a function from the manifold # to ambient csp = hsym((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 = hsym((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)))