---
title: Givens-Rotation Bidiagonal Updates
url: https://www.emergentmind.com/topics/givens-rotation-bidiagonal-updates
type: topic
---

# Givens-Rotation Bidiagonal Updates

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 [2509.02840].

## 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 [2509.02840].

## 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 [2509.02840].

## 3. Pseudocode and Computational Complexity

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

```plaintext
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 [2509.02840].

## 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 [2509.02840].

## 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 [2509.02840].

## 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 [2509.02840].

## 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 [2509.02840].

Source: https://www.emergentmind.com/topics/givens-rotation-bidiagonal-updates