Papers
Topics
Authors
Recent
Search
2000 character limit reached

Riemannian Block Coordinate Descent

Updated 4 July 2026
  • RBCD is a family of optimization methods that update manifold block variables one at a time while maintaining feasibility via retractions or the exponential map.
  • It encompasses formulations based on product manifolds, tangent subspaces, and matrix-manifold coordinates for diverse applications.
  • RBCD offers computational efficiency and provable convergence in tasks ranging from robust optimal transport to essential matrix estimation under manifold-specific conditions.

Riemannian Block Coordinate Descent (RBCD) denotes a family of block-wise optimization methods on Riemannian manifolds in which one updates one block variable, one tangent-space coordinate or block, or one tangent subspace at a time while maintaining feasibility through the exponential map or a retraction. In the recent literature, the term covers at least three closely related formulations: block coordinate descent on product manifolds M=M1×⋯×MbM=M_1\times\cdots\times M_b, tangent-subspace methods that replace Euclidean coordinate blocks by subspaces Sk⊆TxMS_k\subseteq T_xM, and coordinate descent algorithms on matrix manifolds built from manifold-specific tangent bases. The same acronym also names a specific fast, scalable algorithm for entropy-regularized Projection Robust Wasserstein distance on the Stiefel manifold (Peng et al., 2023, Gutman et al., 2019, Han et al., 2024, Huang et al., 2020).

1. Problem formulations and basic definitions

A standard product-manifold formulation considers

min⁡x∈MF(x),M:=M1×⋯×Mb,\min_{x\in M} F(x), \qquad M:=M_1\times\cdots\times M_b,

where each block xi∈Mi⊂Rnix_i\in M_i\subset \mathbb{R}^{n_i} and each MiM_i is a smooth embedded submanifold in the convergence-rate setting. The Euclidean partial gradient ∇iF(x)\nabla_iF(x) is projected onto TxiMiT_{x_i}M_i to obtain the Riemannian partial gradient ∇~iF(x)\widetilde{\nabla}_iF(x), and the full Riemannian gradient is ∇~F(x)=[∇~1F(x);… ;∇~bF(x)]\widetilde{\nabla}F(x)=[\widetilde{\nabla}_1F(x);\dots;\widetilde{\nabla}_bF(x)]. For general closed sets, stationarity is expressed by the tangent cone condition

⟨∇F(x),v⟩≥0∀v∈TM(x),\langle \nabla F(x),v\rangle \ge 0 \quad \forall v\in T_M(x),

which reduces to ∇~F(x)=0\widetilde{\nabla}F(x)=0 on smooth manifolds (Peng et al., 2023).

A second formulation, introduced as Tangent Subspace Descent (TSD), treats Euclidean coordinate blocks as tangent subspaces of a manifold. At iterate xkx_k, one selects a tangent subspace Sk⊆TxkMS_k\subseteq T_{x_k}M with orthogonal projection PSkP_{S_k}, and updates by

$x_{k+1}=\Exp_{x_k}\big(-\alpha_k P_{S_k}\nabla f(x_k)\big),$

or, more generally, with a retraction RR,

xk+1=Rxk(−αkPSk∇f(xk)).x_{k+1}=R_{x_k}\big(-\alpha_k P_{S_k}\nabla f(x_k)\big).

In this formulation, RBCD is not tied to a product decomposition of variables; the “blocks” are tangent subspaces selected at the current iterate (Gutman et al., 2019).

A third formulation specializes to matrix manifolds. There, coordinates are chosen with respect to a basis {Bℓ}\{B_\ell\} spanning TXMT_XM, not necessarily orthonormal, and a block is a structured subset of entries or a tangent subspace. The generic update is

xk+1=Rxk(αkξk),ξk=PBk grad f(xk),x_{k+1}=R_{x_k}(\alpha_k\xi_k), \qquad \xi_k=P_{B_k}\,\mathrm{grad}\,f(x_k),

with PBk(U):=⟨U,Bk⟩xkBkP_{B_k}(U):=\langle U,B_k\rangle_{x_k}B_k. A central identity is

θ=⟨grad f(X),B⟩X=⟨∇f(X),B⟩,\theta=\langle \mathrm{grad}\,f(X),B\rangle_X=\langle \nabla f(X),B\rangle,

which permits coordinate derivatives to be computed directly from the Euclidean gradient (Han et al., 2024).

When M=RnM=\mathbb{R}^n, these constructions reduce to classical Euclidean block coordinate descent: tangent spaces become the ambient space, $\Exp_x(v)=x+v$, and the update becomes x+=x−αPB∇f(x)x^+=x-\alpha P_B\nabla f(x) (Gutman et al., 2019, Han et al., 2024).

2. Update rules and algorithmic families

The product-manifold literature distinguishes three principal block updates. Block Exact Minimization (BEM) updates block ii by solving

xit+1∈arg⁡min⁡u∈MiF(x1t+1,…,xi−1t+1,u,xi+1t,…,xbt).x_i^{t+1}\in \arg\min_{u\in M_i}F(x_1^{t+1},\dots,x_{i-1}^{t+1},u,x_{i+1}^t,\dots,x_b^t).

Block Majorization–Minimization (BMM) replaces the block objective by a block-ii majorizer GiG_i and minimizes that surrogate. Block Riemannian Gradient Descent (BRGD) uses

xit+1←Retrxit(sit),sit=−λit ∇~iF(x1t+1,…,xi−1t+1,xit,xi+1t,…,xbt).x_i^{t+1}\gets \mathrm{Retr}_{x_i^t}(s_i^t),\qquad s_i^t=-\lambda_i^t\,\widetilde{\nabla}_iF(x_1^{t+1},\dots,x_{i-1}^{t+1},x_i^t,x_{i+1}^t,\dots,x_b^t).

A blended scheme applies BRGD on some blocks and exact minimization on others (Peng et al., 2023).

The constrained block-Riemannian optimization literature places these methods in a block majorization-minimization template. At iteration kk, a block bkb_k is chosen, a surrogate QbkkQ_{b_k}^k is built so that Qbkk(z)≥f(x1k,…,z,…,xBk)Q_{b_k}^k(z)\ge f(x_1^k,\dots,z,\dots,x_B^k) and Qbkk(xbkk)=f(xk)Q_{b_k}^k(x_{b_k}^k)=f(x^k), and the update minimizes the surrogate over the feasible block set. A first-order quadratic tangent-space surrogate recovers RBCD as a prox-linear special case (Li et al., 2023).

On matrix manifolds, cyclic, random, and Gauss–Southwell selection rules are natural. A fixed-order cyclic sweep updates blocks B1,…,B∣J∣B_1,\dots,B_{|\mathcal J|}, a random rule samples a block uniformly, and a Gauss–Southwell rule chooses the block maximizing ∣⟨∇f(x),B⟩∣|\langle \nabla f(x),B\rangle|. The same literature also introduces a first-order approximation variant, RCDlin, which anchors the Euclidean gradient at XkX_k, performs SS inner block updates with that fixed gradient, and evaluates ∇f\nabla f only once per outer iteration (Han et al., 2024).

Family Representative update Setting
BEM exact minimization over one block product manifolds
BMM minimization of a block majorizer GiG_i or QbkQ_b^k constrained block-Riemannian optimization
BRGD xit+1=Retrxit(−λit∇~iF)x_i^{t+1}=\mathrm{Retr}_{x_i^t}(-\lambda_i^t\widetilde{\nabla}_iF) smooth embedded product manifolds
TSD xk+1=Rxk(−αkPSk∇f(xk))x_{k+1}=R_{x_k}(-\alpha_kP_{S_k}\nabla f(x_k)) tangent-subspace blocks
RCDlin Xks+1=RXks(−η θksBℓks)X_{k}^{s+1}=R_{X_k^s}(-\eta\,\theta_k^s B_{\ell_k^s}) with anchored ∇f(Xk)\nabla f(X_k) matrix manifolds

The distinction among these schemes is substantive. In BEM and BMM, the block step may be a small exact or surrogate minimization. In BRGD and TSD, the step is explicitly first order. In matrix-manifold RCD, the blocks are often chosen to exploit closed-form retractions with very low per-update cost (Peng et al., 2023, Li et al., 2023, Gutman et al., 2019, Han et al., 2024).

3. Geometry of blocks on matrix and manifold domains

The Stiefel manifold,

St(d,k)={U∈Rd×k∣U⊤U=Ik},\mathrm{St}(d,k)=\{U\in\mathbb{R}^{d\times k}\mid U^\top U=I_k\},

is central in RBCD. Its tangent space is

TUSt(d,k)={Ξ∈Rd×k∣U⊤Ξ+Ξ⊤U=0},T_U\mathrm{St}(d,k)=\{\Xi\in\mathbb{R}^{d\times k}\mid U^\top\Xi+\Xi^\top U=0\},

and the Euclidean-metric projection is

ProjTUSt(Z)=Z−U Sym(U⊤Z).\mathrm{Proj}_{T_U\mathrm{St}}(Z)=Z-U\,\mathrm{Sym}(U^\top Z).

Common retractions include the QR retraction and the polar retraction. For matrix-manifold coordinate descent on Stiefel, basis directions of the form Bij=HijXB_{ij}=H_{ij}X, with Hij=eiej⊤−ejei⊤H_{ij}=e_ie_j^\top-e_je_i^\top, yield Givens-rotation updates

X+=Gij(−ηθij)X,X^+=G_{ij}(-\eta\theta_{ij})X,

which modify only rows ii and jj and cost O(p)O(p) per update (Huang et al., 2020, Han et al., 2024).

The Grassmann manifold uses the horizontal tangent representation

TXGr(p,n)={Δ∈Rn×p∣X⊤Δ=0},projX(G)=(I−XX⊤)G.T_X\mathrm{Gr}(p,n)=\{\Delta\in\mathbb{R}^{n\times p}\mid X^\top\Delta=0\}, \qquad \mathrm{proj}_X(G)=(I-XX^\top)G.

The same Givens-style update is valid, and the matrix-manifold literature proves that it commutes with right actions, making it well defined on equivalence classes [X]={XQ:Q∈O(p)}[X]=\{XQ:Q\in O(p)\} (Han et al., 2024).

TSD constructs blocks directly in tangent spaces. On O(n)O(n), the tangent space is TYOn={YA:A∈Skewn}T_YO_n=\{YA:A\in\mathrm{Skew}_n\}, and block subspaces are induced by partitions of an orthonormal skew basis into sets BkB_k. Under a “disjoint pairs” assumption, the exponential of the block generator decomposes into independent 2×22\times2 Givens blocks. On St(n,p)\mathrm{St}(n,p), the randomized rule uses one-dimensional subspaces spanning skew and normal components, with sampled directions UHijUH_{ij} or veℓ,p⊤ve_{\ell,p}^\top, where v∈Ker(U⊤)v\in\mathrm{Ker}(U^\top) is sampled uniformly from the unit sphere (Gutman et al., 2019).

The matrix-manifold framework extends the same principle to other geometries. For fixed-rank SPSD matrices represented as X=YY⊤X=YY^\top, the tangent space at YY is Euclidean, the gradient is grad f(Y)=2∇f(YY⊤)Y\mathrm{grad}\,f(Y)=2\nabla f(YY^\top)Y, and single-entry updates

Y+=Y−ηθijeiej⊤Y^+=Y-\eta\theta_{ij}e_ie_j^\top

have O(1)O(1) update cost. For SPD matrices with the Bures–Wasserstein metric, coordinate steps use basis directions EijX+XEijE_{ij}X+XE_{ij} and alter only two rows and columns. For generalized hyperbolic manifolds, symplectic manifolds, doubly stochastic manifolds, and multinomial manifolds, the literature supplies manifold-specific bases, closed-form coordinate derivatives, and retractions such as Lorentz boosts, symplectic exponentials, coordinate Sinkhorn, and row normalization (Han et al., 2024).

A recurrent structural fact is that the block is defined in the tangent geometry, not merely in ambient coordinates. This is why apparently similar “coordinate descent” constructions can differ materially across manifolds.

4. Assumptions, convergence guarantees, and complexity regimes

The TSD analysis assumes a geodesically complete Riemannian manifold, smoothness in the form

∥Γxy∇f(x)−∇f(y)∥y≤Lfd(x,y),\|\Gamma_x^y\nabla f(x)-\nabla f(y)\|_y\le L_f d(x,y),

and either the deterministic (γ,r)(\gamma,r)-gap ensuring condition or the randomized CC-randomized norm condition. Under block smoothness and (γ,r)(\gamma,r)-gap ensuring, the deterministic multi-block method satisfies lim⁡t→∞∥∇f(xt)∥=0\lim_{t\to\infty}\|\nabla f(x^t)\|=0, any limit point is stationary, the stationarity rate is O(m/t)O(m/\sqrt t), and for gg-convex objectives the function-value rate is O(m2/t)O(m^2/t). Under the CC-randomized norm condition, the randomized single-block method yields expected stationarity

min⁡s≤tE∥∇f(xs−1)∥≤2Lf(f(x0)−f∗)C2t,\min_{s\le t}\mathbb E\|\nabla f(x^{s-1})\| \le \sqrt{\frac{2L_f(f(x^0)-f^*)}{C^2t}},

almost sure convergence of ∥∇f(xt)∥\|\nabla f(x^t)\| to zero, and an O(1/t)O(1/t) expected function-value bound under gg-convexity (Gutman et al., 2019).

The product-manifold BRGD analysis assumes compact smooth submanifolds, block-ii Lipschitz smoothness of the Euclidean partial gradients, and smooth retractions with blockwise descent lemmas. With cyclic BRGD and stepsizes λit=1/Li\lambda_i^t=1/L_i, the theory gives

min⁡t=0,…,T∥∇~F(xt)∥≤b Cb F(x0)−F(xT+1)T+1,\min_{t=0,\dots,T}\|\widetilde{\nabla}F(x^t)\| \le \sqrt{b}\,C_b\,\sqrt{\frac{F(x^0)-F(x^{T+1})}{T+1}},

hence iteration complexity O(Cb2(F(x0)−F∗)/ε2)\mathcal O(C_b^2(F(x^0)-F^*)/\varepsilon^2) to reach ε\varepsilon-stationarity. The blended BEM+RGD scheme admits an analogous bound with b−1b-1 gradient-updated blocks (Peng et al., 2023).

The RBMM analysis addresses smooth nonconvex objectives over X=X1×⋯×XB⊆M1×⋯×MBX=X_1\times\cdots\times X_B\subseteq M_1\times\cdots\times M_B, with geodesic smoothness, compact sublevel sets, a uniform injectivity radius bound, and either gg-smooth, Riemannian proximal, or Euclidean proximal surrogates. Every limit point is stationary under the stated assumptions. For proximal surrogates, the worst-case iteration complexity for the paper’s ε\varepsilon-stationarity measure is O~(ε−2)\widetilde O(\varepsilon^{-2}); for gg-smooth surrogates, the general complexity is O~(ε−4)\widetilde O(\varepsilon^{-4}), improved to O~(ε−2)\widetilde O(\varepsilon^{-2}) under an upper quadratic surrogate-gap bound. On products of Euclidean and Stiefel manifolds, the assumptions become completely Euclidean while the analysis remains Riemannian (Li et al., 2023).

The matrix-manifold RCD and RCDlin analyses assume a compact neighborhood around a critical point, bounded basis and projection constants, and retraction LL-smoothness. Randomized RCD with one inner step and η=Θ(1/L)\eta=\Theta(1/L) satisfies

min⁡0≤k≤K−1∥grad f(Xk)∥Xk2≤O ⁣(∣J∣ LK),\min_{0\le k\le K-1}\|\mathrm{grad}\,f(X_k)\|_{X_k}^2\le O\!\left(\frac{|\mathcal J|\,L}{K}\right),

whereas cyclic RCD yields

min⁡0≤k≤K−1∥grad f(Xk)∥Xk2≤O ⁣(∣J∣2 LK).\min_{0\le k\le K-1}\|\mathrm{grad}\,f(X_k)\|_{X_k}^2\le O\!\left(\frac{|\mathcal J|^2\,L}{K}\right).

For RCDlin, the randomized rate becomes O(∣J∣L/(KS))O(|\mathcal J|L/(KS)) under a positive-correlation condition between anchored and true block derivatives (Han et al., 2024).

A distinct convergence template appears in non-orthogonal joint approximate diagonalization on St(m,n,C)×SLm(C)\mathrm{St}(m,n,\mathbb C)\times SL_m(\mathbb C). There, gradient-based BCD-G algorithms choose the block according to the Riemannian gradient magnitude, use Wolfe line search on the Stiefel block, and use structured elementary transformations on the special linear block. Under bounded iterates, the whole sequence converges and every limit point is stationary, with the proof based on sufficient descent and the Łojasiewicz gradient inequality (Li et al., 2020).

These results are not interchangeable. Their rates, stationarity measures, and assumptions depend on whether blocks are product components, tangent subspaces, or manifold-specific coordinates.

5. The Projection Robust Wasserstein instance

A prominent specialized use of the acronym is the RBCD algorithm for computing the Projection Robust Wasserstein (PRW) distance. For empirical measures μn=∑i=1nriδxi\mu_n=\sum_{i=1}^n r_i\delta_{x_i} and νn=∑j=1ncjδyj\nu_n=\sum_{j=1}^n c_j\delta_{y_j}, the squared PRW distance is

Pk2(μn,νn)=max⁡U∈St(d,k)min⁡π∈Π(μn,νn)∑i,j=1nπij ∥U⊤xi−U⊤yj∥2.P_k^2(\mu_n,\nu_n) = \max_{U\in \mathrm{St}(d,k)} \min_{\pi\in\Pi(\mu_n,\nu_n)} \sum_{i,j=1}^n \pi_{ij}\,\|U^\top x_i-U^\top y_j\|^2.

The entropy-regularized version introduces

H(π):=−∑i,j(πijlog⁡πij−πij),H(\pi):=-\sum_{i,j}(\pi_{ij}\log\pi_{ij}-\pi_{ij}),

and maximizes over U∈St(d,k)U\in\mathrm{St}(d,k) the inner regularized OT value. The key reformulation dualizes the inner RegOT and obtains a smooth minimization problem over two Euclidean blocks u,v∈Rnu,v\in\mathbb R^n and one Stiefel block UU: min⁡U∈St(d,k), u,v∈Rng(u,v,U)=log⁡∥ζ(u,v,U)∥1−r⊤u−c⊤v,\min_{U\in\mathrm{St}(d,k),\,u,v\in\mathbb R^n} g(u,v,U) = \log\|\zeta(u,v,U)\|_1-r^\top u-c^\top v, where

[ζ(u,v,U)]ij=exp⁡(−1η∥U⊤(xi−yj)∥2+ui+vj),π=ζ/∥ζ∥1.[\zeta(u,v,U)]_{ij} = \exp\left(-\frac{1}{\eta}\|U^\top(x_i-y_j)\|^2+u_i+v_j\right), \qquad \pi=\zeta/\|\zeta\|_1.

This removes the need to solve an entropy-regularized optimal transport problem in each iteration (Huang et al., 2020).

The resulting RBCD iteration has three blocks. The uu- and vv-updates are closed-form marginal scaling steps,

ut+1=ut+log⁡(r ./ φ(ζ(ut,vt,Ut))),u^{t+1}=u^t+\log\big(r\,./\,\varphi(\zeta(u^t,v^t,U^t))\big),

vt+1=vt+log⁡(c ./ κ(ζ(ut+1,vt,Ut))),v^{t+1}=v^t+\log\big(c\,./\,\kappa(\zeta(u^{t+1},v^t,U^t))\big),

which are exactly the row and column scaling steps of Sinkhorn applied analytically to ζ\zeta. The UU-block performs one Riemannian gradient step with retraction: ξt+1=ProjTUtSt(−2ηVπtUt),Ut+1=RetrUt(−τ ξt+1),\xi^{t+1} = \mathrm{Proj}_{T_{U^t}\mathrm{St}} \left( -\frac{2}{\eta}V_{\pi^t}U^t \right), \qquad U^{t+1}=\mathrm{Retr}_{U^t}(-\tau\,\xi^{t+1}), with

Vπ=∑i,jπij(xi−yj)(xi−yj)⊤.V_\pi=\sum_{i,j}\pi_{ij}(x_i-y_j)(x_i-y_j)^\top.

Feasibility of the transport matrix is enforced at the end by a rounding procedure that corrects marginals and yields π^∈Π(μn,νn)\hat\pi\in\Pi(\mu_n,\nu_n).

The theoretical gain is substantial. The arithmetic complexity to obtain an (ϵ1,ϵ2)(\epsilon_1,\epsilon_2)-stationary point is

O ⁣((n2dk+dk2+k3)log⁡n(1ϵ23+1ϵ12ϵ2)),O\!\left((n^2dk+dk^2+k^3)\log n\left(\frac{1}{\epsilon_2^3}+\frac{1}{\epsilon_1^2\epsilon_2}\right)\right),

and in the common case ϵ1=ϵ2=ϵ\epsilon_1=\epsilon_2=\epsilon and k=O(1)k=O(1), this becomes O((n2dk+dk2+k3)log⁡n⋅ϵ−3)O((n^2dk+dk^2+k^3)\log n\cdot \epsilon^{-3}). The comparison paper reports O(ϵ−12)O(\epsilon^{-12}) complexity for RGAS, which solves a Sinkhorn subproblem to high accuracy at every iteration. Per iteration, RBCD costs O(n2dk+dk2+k3)O(n^2dk+dk^2+k^3), with uu- and vv-updates of O(n)O(n), VπUV_\pi U computed in O(n2dk)O(n^2dk) without forming VπV_\pi, and QR or polar retraction in O(dk2+k3)O(dk^2+k^3).

The experiments cover synthetic fragmented hypercube and Gaussian models and real data including movie scripts, Shakespeare plays, and MNIST. On the fragmented hypercube with k=k∗=2k=k^*=2, the reported runtimes include $0.18$ s, $1.83$ s, and $8.51$ s for RBCD at n=100,500,1000n=100,500,1000, versus $0.40$ s, $2.90$ s, and $10.25$ s for RGAS. For large scale d=250d=250, n=2500n=2500, the reported runtime is $354.91$ s for RBCD versus $427.24$ s for RGAS. The paper also reports similar PRW values across methods, robustness to white noise in the Gaussian setting, and an adaptive variant, RABCD, with empirically faster convergence and the same order complexity up to a 1/α1/\alpha factor (Huang et al., 2020).

6. Applications, relations, and limitations

RBCD appears in a broad range of nonconvex manifold problems. The product-manifold framework covers low-dimensional structure problems such as maximal coding rate reduction, neural collapse, generalized PCA, and alternating projection; combinatorial structure problems such as homomorphic sensing, regression without correspondences, real phase retrieval, and robust point matching; geometric-vision problems such as essential matrix estimation and absolute pose estimation; and outlier-robust estimation via iteratively-reweighted least squares. The same theory recovers previously known results for optimal transport, matrix factorization, and Burer–Monteiro factorization, and yields explicit corollaries for GPCA, essential matrix estimation, PRWD, IRLS, and block-diagonal SDP factorizations (Peng et al., 2023).

The matrix-manifold coordinate literature emphasizes computational efficiency in applications such as orthogonal Procrustes on Stiefel, PCA on Grassmann, orthogonal deep network distillation, nearest matrix on the symplectic manifold, Lorentz embeddings, and weighted least squares on SPD or SPSD manifolds. Its practical message is that row-pair rotations, single-entry factor updates, and 2×22\times2 coordinate Sinkhorn updates can be markedly cheaper than full Riemannian gradient or trust-region steps, especially when retraction costs dominate (Han et al., 2024).

In non-orthogonal joint approximate diagonalization, RBCD operates on the product of the complex Stiefel manifold and the special linear group. One block uses Riemannian line-search descent on the Stiefel factor, and the other uses plane Givens, triangular, or diagonal transformations on the special linear factor, producing BCD-GLU, BCD-GQU, and BCD-GU. The square-case Jacobi analogues on SLm(C)SL_m(\mathbb C) are Jacobi-GLU and Jacobi-GQU. Under bounded iterates, the whole sequence converges and the gradient vanishes (Li et al., 2020).

Several limitations recur across the literature. First, nonconvexity remains intrinsic: the general guarantees are to stationary points or ε\varepsilon-stationary points, not to global minimizers. Second, block or subspace selection matters. TSD gives counterexamples showing that poorly chosen subspaces can prevent convergence even if they span the tangent space at each step; the deterministic gap ensuring and randomized CC-randomized norm conditions were introduced precisely to exclude such failures (Gutman et al., 2019). Third, low per-iteration cost does not remove all large-scale bottlenecks. In PRW, the O(n2)O(n^2) dependence persists even though the method avoids solving a full Sinkhorn problem at every iteration, and the performance remains sensitive to η\eta and τ\tau (Huang et al., 2020). Fourth, different RBCD papers use different block notions—product blocks, tangent subspaces, or manifold-specific coordinates—so results from one setting should not be transferred mechanically to another. A plausible implication is that “RBCD” is best understood as a methodological class rather than a single canonical algorithm.

Across these formulations, the common design principle is stable: restrict the search to a geometrically meaningful block, compute a blockwise Riemannian descent direction, and return to the manifold by $\Exp$ or a retraction. The differences lie in how the blocks are defined, which assumptions are used to prove descent, and how aggressively the algorithm exploits manifold structure for closed-form or low-cost updates.

Topic to Video (Beta)

No one has generated a video about this topic yet.

Whiteboard

No one has generated a whiteboard explanation for this topic yet.

Follow Topic

Get notified by email when new papers are published related to Riemannian Block Coordinate Descent (RBCD).