Orthogonal and unitary matrices

The formula

The defining property, real case:

Qᵀ · Q = Q · Qᵀ = I        (equivalently  Q⁻¹ = Qᵀ)

Reading: the columns of Q are mutually perpendicular unit vectors, and inverting Q costs nothing — just flip it across the diagonal.

The complex generalization, the unitary matrix:

U* · U = U · U* = I        (U* = conjugate transpose, U⁻¹ = U*)

Reading: same idea with complex entries; conjugate-and-transpose plays the role transpose played. Every orthogonal matrix is unitary — a unitary matrix that happens to be real ^[1]^[2].

What the property buys you:

‖Q·x‖ = ‖x‖               lengths preserved, always
(Q·x)·(Q·y) = x·y          angles and inner products preserved
det(Q) = ±1                (+1 rotation, −1 reflection);  |det(U)| = 1
|λᵢ| = 1                   every eigenvalue sits on the unit circle
cond(Q) = 1                the smallest condition number a matrix can have

Reading: multiplying by Q moves the coordinate frame and does nothing else. No amplification means rounding errors ride through unmagnified — the reason numerical analysts build almost everything out of these ^[1].

The two standard building blocks:

Householder reflection:  H = I − 2·v·vᵀ/(vᵀ·v)     mirrors across the plane ⊥ v
Givens rotation:         2×2 block  | c  −s |       c = cos θ, s = sin θ,
                                    | s   c |       rotates in one coordinate plane

Reading: a reflector zeros a whole column segment at once; a rotation zeros one entry at a time. Chain either and you get QR factorization ^[5]^[8].

Where you meet it

The strapdown IMU on your test article. The direction cosine matrix that carries body frame to nav frame is a 3×3 rotation — orthogonal, det +1. The gotcha is that floating point doesn't respect the group: propagate a DCM with a million successive 1° incremental updates in single precision and the columns grow about 1.5% long, with an orthogonality error near 0.03. Your "rotation" is now quietly scaling the world. This is why every attitude propagation loop renormalizes — re-orthogonalize the DCM, or keep the attitude in a quaternion and normalize that. If your nav solution drifts in ways the gyro spec can't explain, check whether anyone is cleaning up the matrix.
S-parameters of anything lossless. For a network that dissipates no power, the scattering matrix is unitary: S*·S = I ^[13]. For a lossless 2-port that means |S₁₁|² + |S₂₁|² = 1 at every frequency — whatever doesn't reflect must transmit. On the bench this is a sanity check on VNA data for a filter or a cable: column norms of S above 1 mean your calibration is lying (a passive network can't gain), and norms well below 1 quantify the loss. The same fact is why an ideal 3 dB hybrid has the phase relationships it does — unitarity forces them.
The FFT, every time you run one. The DFT with symmetric 1/√N scaling is a unitary matrix, which is exactly Parseval's theorem: signal energy in the time record equals signal energy in the spectrum. When the PSD from a shaker run doesn't integrate back to the time-domain RMS you measured, the transform didn't lose the energy — somebody's scaling convention did. Chasing factor-of-N and √N discrepancies between MATLAB, Python, and the analyzer's firmware is a rite of passage; unitarity is the anchor that tells you which answer is right.
At the review board, when least squares comes up. Fitting a model by forming the normal equations AᵀA·x = Aᵀb squares the condition number: a fifth-order polynomial fit (six coefficients) to 12 points equally spaced on [0, 1] has cond(A) ≈ 3.1×10³ and hands the normal equations cond(AᵀA) ≈ 9.8×10⁶ — three to four digits of your double precision gone before the solve starts. QR factorization applies orthogonal transformations to A directly and never squares anything. If a briefing chart shows (AᵀA)⁻¹Aᵀ as the implementation rather than the notation, that's a finding.

How it works

Start with what "orthogonal" actually requires. The columns must be perpendicular and unit length — orthonormal is the real condition, and the standard name is a historical misnomer everyone has agreed to live with. Perpendicular columns of the wrong length give you QᵀQ = D (diagonal, not identity), and everything downstream that assumed Q⁻¹ = Qᵀ is now wrong by those scale factors.

The geometric content: an orthogonal matrix is a rigid motion of space about the origin. det = +1 is a pure rotation; det = −1 includes a reflection ^[1]. That sign matters on hardware. A rotation matrix reconstructed from noisy calibration data (camera extrinsics, laser tracker fits, photogrammetry) can come out with determinant −1 — a mirror world where your right-handed coordinate frame went left-handed and every cross product flips sign. Check the determinant before you trust a fitted rotation; the fix is one column sign flip in the SVD-based reconstruction.

Closure is what makes them composable: the product of orthogonal matrices is orthogonal, the inverse is orthogonal, and the n×n set forms the orthogonal group O(n), with the rotations alone forming SO(n) ^[1]. In exact arithmetic you can chain a thousand frame transformations and the result is still a rigid motion. In floating point each product injects rounding at roughly machine epsilon, and the errors accumulate off the group — hence the DCM drift above. The errors stay small per step; they just never cancel. Long chains need periodic re-orthogonalization, and the clean way is one QR or SVD of the drifted matrix.

Three standard mistakes:

Transpose instead of conjugate transpose. With complex data — S-parameters, FFT outputs, baseband IQ — the inverse of a unitary matrix is U*, not Uᵀ. In NumPy that is U.conj().T, and plain .T runs without complaint while producing garbage. If a complex "inverse rotation" isn't undoing the forward one, look here first.
Interpolating rotation matrices entrywise. The average of two rotation matrices is not a rotation — averaging a 0° and a 180° rotation about z gives a rank-deficient matrix, not a 90° one. Blend attitudes through quaternions or the axis-angle form, then convert back.
Assuming a rectangular Q is fully orthogonal. The thin QR of a tall matrix gives Q (say 1000×6) with QᵀQ = I₆ but QQᵀ ≠ I — it projects, it doesn't preserve everything. Semi-orthogonal matrices preserve the lengths of vectors already in their column space and annihilate part of everything else.

Why numerical libraries are built from these: applying an orthogonal transformation cannot amplify error, because cond(Q) = 1 and ‖Q·(x + e)‖ − ‖Q·x‖ is bounded by ‖e‖ exactly ^[1]. Gaussian elimination has to police element growth with pivoting; Householder QR gets stability for free from geometry. That is the entire argument for QR over normal equations, for QR-based eigensolvers, and for the SVD — whose outer factors are orthogonal, which is why it is the most trustworthy factorization in the toolbox. The price is arithmetic: Householder QR costs about twice the flops of the normal-equations route. You are buying digits with flops, and on modern hardware the digits are the scarce resource.

One more distinction worth keeping straight: unitarity in physics is conservation. A unitary scattering matrix conserves power ^[13]; a unitary time-evolution matrix in quantum mechanics conserves total probability ^[2]; a unitary transform conserves signal energy. Same theorem, three badges.

History

The subject starts as geometry. Rigid coordinate changes — the substitutions preserving x² + y² + z² — were classical territory, and in 1846 Arthur Cayley published a four-page paper in Crelle's journal, "Sur quelques propriétés des déterminants gauches," showing how to manufacture almost every rotation from a skew-symmetric array via what we now call the Cayley transform, Q = (I − A)(I + A)⁻¹ ^[3]^[4] — every proper rotation that doesn't turn some plane by exactly 180°, and never a reflection, since the construction always yields det = +1. Feed it the simplest 2×2 skew matrix and out comes an exact 90° rotation. That 180° exclusion should sound familiar: the Rodrigues/Gibbs attitude parameters are precisely the Cayley transform of a skew matrix, and this is where their singularity comes from. This was a decade before Cayley's 1858 memoir founded matrix algebra proper — the orthogonal matrices showed up before matrices officially existed.

The orthonormalization recipe every engineer learns arrived piecewise. Laplace had used the essential process long before either eponym; Jørgen Gram used it in his work on least squares; and in 1907 Erhard Schmidt, a student of Hilbert, stated it in the form now taught, as a lemma in a paper on integral equations ^[11]^[12]. Fairness would call it the Laplace–Gram–Schmidt process. Nobody does.

The modern subject — orthogonal matrices as the safe tools of computation — is a product of the first computer labs, and it happened fast. Wallace Givens, computing eigenvalues at Oak Ridge, introduced his plane rotations in a 1954 lab report (ORNL-1574) and published the general triangularization method in 1958 ^[7]^[8]; he later went on to direct the Applied Mathematics Division at Argonne. Down the hall, Alston Householder, head of the mathematics division at Oak Ridge, published in 1958 "Unitary Triangularization of a Nonsymmetric Matrix" in the Journal of the ACM — four pages introducing the reflector that now carries his name ^[5]^[6]. Then in 1959–61 John Francis in London and Vera Kublanovskaya in Leningrad, working independently and unaware of each other, built the QR algorithm on exactly these orthogonal transformations ^[9]^[10]. It remains the standard way eigenvalues get computed. James Wilkinson, the field's great error analyst, credited Householder with bringing order to the chaos of competing matrix algorithms ^[6] — and the organizing principle was simple: when rounding error is the enemy, do everything with matrices that cannot amplify it.

Related tools

/tools/convert-angle
/tools/vswr-return-loss
/tools/vibration-natural-freq
/tools/antenna-gain-beamwidth

Sources

Written by HE in our own words from the cited sources — engineering judgment included, your stamp still required. All entries →