t3toolbox.backend.bcf_operations.orthogonal_representations =========================================================== .. py:function:: t3toolbox.backend.bcf_operations.orthogonal_representations(x: t3toolbox.backend.common.typ.Union[t3toolbox.backend.common.typ.Tuple[t3toolbox.backend.common.typ.Tuple[t3toolbox.backend.common.NDArray, Ellipsis], t3toolbox.backend.common.typ.Tuple[t3toolbox.backend.common.NDArray, Ellipsis]], t3toolbox.backend.common.typ.Tuple[t3toolbox.backend.common.NDArray, t3toolbox.backend.common.NDArray]], already_left_orthogonal: bool = False, squash: bool = True, use_jax: bool = False) -> t3toolbox.backend.common.typ.Union[t3toolbox.backend.common.typ.Tuple[t3toolbox.backend.common.typ.Tuple[t3toolbox.backend.common.typ.Tuple[t3toolbox.backend.common.NDArray, Ellipsis], t3toolbox.backend.common.typ.Tuple[t3toolbox.backend.common.NDArray, Ellipsis], t3toolbox.backend.common.typ.Tuple[t3toolbox.backend.common.NDArray, Ellipsis], t3toolbox.backend.common.typ.Tuple[t3toolbox.backend.common.NDArray, Ellipsis]], t3toolbox.backend.common.typ.Tuple[t3toolbox.backend.common.typ.Tuple[t3toolbox.backend.common.NDArray, Ellipsis], t3toolbox.backend.common.typ.Tuple[t3toolbox.backend.common.NDArray, Ellipsis]]], t3toolbox.backend.common.typ.Tuple[t3toolbox.backend.common.typ.Tuple[t3toolbox.backend.common.NDArray, t3toolbox.backend.common.NDArray, t3toolbox.backend.common.NDArray, t3toolbox.backend.common.NDArray], t3toolbox.backend.common.typ.Tuple[t3toolbox.backend.common.NDArray, t3toolbox.backend.common.NDArray]]] Construct base-variation representations of TuckerTensorTrain with orthogonal base. Input TuckerTensorTrain:: 1 -- G0 -- G1 -- G2 -- G3 -- 1 X = | | | | B0 B1 B2 B3 | | | | Base-variation representation with non-orthogonal TT-backend H1:: 1 -- L0 -- H1 -- R2 -- R3 -- 1 X = | | | | U0 U1 U2 U3 | | | | Base-variation representation with non-orthogonal tucker backend V2:: 1 -- L0 -- L1 -- O2 -- R3 -- 1 X = | | | | U0 U1 V2 U3 | | | | The input tensor train x is defined by: - x_tucker_cores = (B0, B1, B2, B3) - x_tt_cores = (G0, G1, G2, G3) The "base cores" are: - tucker_cores = (U0,U1, U2, U3), up orthogonal - left_tt_cores = (L0, L1, L2), left orthogonal - right_tt_cores = (R1, R2, R3), right orthogonal - outer_tt_cores = (O0, O1, O2, O3), down orthogonal The "variation cores" are: - tucker_variations = (V0, V1, V2, V3) - tt_variations = (H0, H1, H2, H3) :param x: Input TuckerTensorTrain x = (x_tucker_cores, x_tt_cores) x_tucker_cores = (B0, ..., B(d-1)) x_tt_cores = (G0, ..., G(d-1)) :type x: TuckerTensorTrain :param xnp: Linear algebra backend. Default: np (numpy) :returns: * *T3Base* -- Orthogonal base for base-variation representations of x. * *T3Variation* -- Variation for base-variation representaions of x. .. rubric:: Examples >>> import numpy as np >>> import t3toolbox.tucker_tensor_train as t3 >>> import t3toolbox.basis_coordinates_format as bcf >>> x = t3.t3_corewise_randn((14,15,16), (4,5,6), (1,3,2,1)) >>> base, variation = bcf.orthogonal_representations(x) # Compute orthogonal representations >>> tucker_cores, left_tt_cores, right_tt_cores, outer_tt_cores = base >>> tucker_vars, tt_vars = variation >>> (U0,U1,U2) = tucker_cores >>> (L0,L1,L2) = left_tt_cores >>> (R0,R1,R2) = right_tt_cores >>> (O0,O1,O2) = outer_tt_cores >>> (V0,V1,V2) = tucker_vars >>> (H0,H1,H2) = tt_vars >>> x2 = ((U0,U1,U2), (L0,H1,R2)) # representation with TT-backend variation in index 1 >>> print(np.linalg.norm(x.to_dense() - x2.to_dense())) # Still represents origional tensor 4.978421562425667e-12 >>> x3 = ((U0,V1,U2), (L0,O1,R2)) # representation with tucker backend variation in index 1 >>> print(np.linalg.norm(x.to_dense() - x3.to_dense())) # Still represents origional tensor 5.4355175448533146e-12 >>> print(np.linalg.norm(U1 @ U1.T - np.eye(U1.shape[0]))) # U: orthogonal 1.1915111872574236e-15 >>> print(np.linalg.norm(np.einsum('iaj,iak->jk', L1, L1) - np.eye(L1.shape[2]))) # L: left orthogonal 9.733823879665448e-16 >>> print(np.linalg.norm(np.einsum('iaj,kaj->ik', R1, R1) - np.eye(R1.shape[0]))) # R: right orthogonal 8.027553546330097e-16 >>> print(np.linalg.norm(np.einsum('iaj,ibj->ab', O1, O1) - np.eye(O1.shape[1]))) # O: outer orthogonal 1.3870474292323159e-15 Example where r0 and rd are not 1: >>> import numpy as np >>> import t3toolbox.tucker_tensor_train as t3 >>> import t3toolbox.orthogonalization as orth >>> x = t3.t3_corewise_randn(((14,15,16), (4,5,6), (2,3,2,2))) >>> base, variation = orth.orthogonal_representations(x) # Compute orthogonal representations >>> tucker_cores, left_tt_cores, right_tt_cores, outer_tt_cores = base >>> tucker_vars, tt_vars = variation >>> (U0,U1,U2) = tucker_cores >>> (L0,L1,L2) = left_tt_cores >>> (R0,R1,R2) = right_tt_cores >>> (O0,O1,O2) = outer_tt_cores >>> (V0,V1,V2) = tucker_vars >>> (H0,H1,H2) = tt_vars >>> x2 = ((U0,U1,U2), (L0,H1,R2)) # representation with TT-backend variation in index 1 >>> print(np.linalg.norm(t3.t3_to_dense(x) - t3.t3_to_dense(x2))) # Still represents origional tensor 2.5341562994067855e-12 >>> x3 = ((V0,U1,U2), (O0,R1,R2)) # representation with tucker backend variation in index 0 >>> print(np.linalg.norm(t3.t3_to_dense(x) - t3.t3_to_dense(x3))) # Still represents origional tensor 2.9206090606788446e-12 >>> print(np.linalg.norm(U0 @ U0.T - np.eye(U0.shape[0]))) # U: orthogonal 1.675264510304594e-15 >>> print(np.linalg.norm(np.einsum('iaj,iak->jk', L0, L0) - np.eye(L0.shape[2]))) # L: left orthogonal 9.046146325204653e-16 >>> print(np.linalg.norm(np.einsum('iaj,kaj->ik', R2, R2) - np.eye(R2.shape[0]))) # R: right orthogonal 1.1775693440128312e-16 >>> print(np.linalg.norm(np.einsum('iaj,ibj->ab', O0, O0) - np.eye(O0.shape[1]))) # O: outer orthogonal 1.2300840868850519e-15