Givens-Rotation Bidiagonal Updates

• The paper introduces Givens-Rotation Bidiagonal Updates as an algorithm that maintains orthogonal-bidiagonal factorizations efficiently under rank-one updates, crucial for high-throughput data processing.
• BGU leverages a two-phase approach using Givens rotations to restore strict upper bidiagonality, achieving quadratic computational complexity and reduced memory demands.
• Empirical evaluations show that BGU outperforms traditional SVD update methods in speed and accuracy across applications such as subspace tracking, recommendation systems, and dynamic graph analysis.

Givens-Rotation Bidiagonal Updates (BGU) are a class of algorithms for maintaining an orthogonal-bidiagonal factorization of a matrix under rank-one updates, using only sequences of Givens rotations. When data streams arrive as low-rank changes, and recomputing a full SVD is prohibitive, BGU efficiently updates the compact bidiagonal form, supporting high-throughput subspace tracking and related computations with rigorous control on complexity and accuracy. The method maintains both algorithmic efficiency and numerical stability and is well-suited for large-scale streaming data scenarios (Brust et al., 2 Sep 2025).

1. Mathematical Setup and Problem Formulation

The BGU technique operates on a factorized matrix representation: $A_k = Q_k B_k P_k,$ where $A_k \in \R^{m \times n}$, both $Q_k \in \R^{m \times m}$ and $P_k \in \R^{n \times n}$ are orthogonal, and $B_k$ is an upper bidiagonal matrix. When a new data block arrives as a rank-one update, $A_{k+1} = A_k + b c^T$ with $b \in \R^m$, $c \in \R^n$, the updated matrix takes the form

$A_{k+1} = Q_k (B_k + \beta \gamma^T )P_k,$

where $\beta = Q_k^T b$ and $\gamma = P_k^T c$. The core objective is to reestablish upper bidiagonal form: $U^T (B_k + \beta \gamma^T ) V = B_{k+1},$ by constructing appropriate orthogonal $U, V$, so the factorization

$A_{k+1} = Q_{k+1} B_{k+1} P_{k+1},$

with $Q_{k+1}=Q_k U$, $P_{k+1}=V^T P_k$, is preserved and $B_{k+1}$ is again upper bidiagonal (Brust et al., 2 Sep 2025).

2. Algorithmic Structure and Givens Rotations

The BGU algorithm exclusively uses Givens rotations to restore bidiagonality after a rank-one update. A Givens rotation $G(i,j,\theta)$, for $i<j$, modifies the $(i,j)$-plane of a matrix by applying a $2 \times 2$ rotation defined by $\cos\theta=c$ and $\sin\theta=s$. To annihilate entries during bidiagonalization, the rotation parameters are taken so that

$$\begin{pmatrix} c & -s \ s & c \end{pmatrix} \begin{pmatrix} \alpha \ x \end{pmatrix} = \begin{pmatrix} r \ 0 \end{pmatrix},$$

with $r=\sqrt{\alpha^2+x^2}$, $c=\alpha/r$, $s=x/r$.

BGU restores the bidiagonal form through two algorithmic phases:

• Phase 1: Sequentially eliminates off-band entries introduced into $\beta$ and $\gamma$, reducing $B_k + \beta\gamma^T$ to a $(p=1, q=2)$ banded matrix, using left- and right-acting Givens rotations.
• Phase 2: Chases and removes bulges on the extra superdiagonal to produce a strict upper bidiagonal.

Each rotation affects at most two dense vectors ($\beta$ or $\gamma$) and two rows or columns of $B_k$, allowing fine-grained, local updates (Brust et al., 2 Sep 2025).

3. Pseudocode and Computational Complexity

The essential operations of BGU can be summarized for an $(r+1)\times(r+1)$ block as follows:

Input: bidiagonal B ∈ R^(r+1×r+1), vectors β, γ ∈ R^(r+1) Output: updated bidiagonal B⁺, and rotations U, V Phase 1: Eliminate β from top to bottom for i = 1 to r: if β[i] ≠ 0: (c, s) ← givens(B[i,i], β[i]) apply G_left(i,i+1,c,s) to rows i,i+1 of B, β for j = i to r−1: (c', s') ← givens(B[i,j+1], B[i,j+2]) apply G_right(j+1,j+2,c',s') to cols j+1,j+2 of B, γ (c'', s'') ← givens(B[j+1,j+1], β[j+1]) apply G_left(j+1,j+2,c'',s'') to rows j+1,j+2 of B, β Phase 2: Eliminate extra superdiagonal for k = 1 to r−1: for j = k to r−1: (c, s) ← givens(B[k,j+1], B[k,j+2]) apply G_right(j+1,j+2,c,s) to cols j+1,j+2 of B, γ Return: B⁺ = B (now bidiagonal), U, V

One Givens rotation, acting on maximally five nonzeros in $B$ plus two dense entries, costs approximately $10$ flops; forming $(c,s)$ requires $3$ flops. Phase 1 performs up to $2r^2$ rotations; phase 2 an additional $2r$. The total cost per update is thus $10(2r^2+2r) = \mathcal{O}(r^2)$ flops, providing a quadratic complexity per update—substantial improvement over cubic-scaling alternatives (Brust et al., 2 Sep 2025).

4. Resource Usage and Implementation Considerations

BGU stores the upper bidiagonal $B$ (only $2r+1$ scalars for an $r\times r$ block), the two update vectors $\beta, \gamma \in \R^{r+1}$, and, if needed, the Givens rotation parameters $\{(i,j,c,s)\}$. For orthogonal factors $Q_k, P_k$, only the sequence of rotations is maintained, avoiding storage of full dense matrices unless required for downstream applications. In contrast, Householder-based methods (such as LAPACK’s dgebrd) incur $\mathcal{O}(mr+nr)$ storage for WY factors plus potentially dense $m\times n$ work panels, making BGU significantly more compact, particularly for large $m, n$ and moderate factorization rank $r$.

In streaming implementations, $Q_k$ and $P_k$ are stored implicitly as products of rotations; new data is projected to the current subspaces by small matrix-vector multiplies to obtain $\beta$ and $\gamma$. Only the bidiagonal spectrum needs to be re-formed and, in practical settings, a fixed $r \ll \min(m, n)$ is maintained, discarding smallest singular pairs to prevent rank growth (Brust et al., 2 Sep 2025).

5. Numerical Stability and Backward Error

Each Givens rotation is precisely orthogonal to working precision, ensuring that overall, the BGU method is backward stable. The discrepancy in Frobenius norm ($\|A\|_F-\|B\|_F$) after the update is of order $\mathcal{O}(u)$ where $u$ is the machine epsilon. Empirical results confirm that the orthogonality of the accumulated $Q_k, P_k$ factors remains within a few units in the last place even after processing thousands of updates. In exact arithmetic, BGU preserves strict bidiagonality—there is no additional structural drift beyond finite precision effects (Brust et al., 2 Sep 2025).

6. Empirical Performance and Applications

Empirical evaluation demonstrates that BGU offers substantial computational advantages and robust accuracy in streaming and dynamic data environments:

Domain	BGU Benchmarks	Competitor	Result
Link prediction	Flickr, Slashdot graphs, ranks up to 5120; $\left|\|A\|_F-\|B\|_F\right|<10^{-11}$	Deng et al. RPI	BGU up to 2× faster, same or better accuracy
Recommendation	MovieLens 32M, 2,000 updates at $r=2,000$	Brand's incremental SVD	BGU ≃ 0.25s/update vs. 0.5s, same accuracy
Sparse benchmarks	SuiteSparse, 43 matrices	LAPACK zgebrd	BGU fastest on >90% cases, often 10–100× faster

In all settings, BGU either outperforms or matches existing state-of-the-art SVD/SVD-type update algorithms on speed and accuracy (Brust et al., 2 Sep 2025).

7. Summary and Significance

Givens-rotation bidiagonal updates enable efficient, low-memory, and numerically stable maintenance of bidiagonal factorizations under rank-one data arrival. With per-update cost $\mathcal{O}(r^2)$ and storage $\mathcal{O}(r)$, BGU is well suited for high-throughput streaming scenarios, outperforming established Householder-based and randomized algorithms in both theory and empirical practice. The method preserves accuracy, orthogonality, and compactness, and is directly applicable to large-scale systems for subspace tracking, recommendation, and dynamic graph analysis (Brust et al., 2 Sep 2025).