Almost every matrix formula in MIMO, beamforming and channel estimation carries a small superscript H. That H is the conjugate transpose, and it is the complex-number version of the ordinary transpose. I'll first show how it is formed, and then list the symbols it goes by. After that we'll go through the rules you need when you rearrange a formula that contains it. The last sections show where it appears in wireless communication and how Matlab and Python compute it.

• How is the conjugate transpose formed ?
• Which symbols stand for the same operation ?
• What rules does the conjugate transpose follow ?
• What are Hermitian and unitary matrices ?
• Where does it appear in wireless communication ?
• How do Matlab and Python compute it ?

How is the conjugate transpose formed ?

Conjugate Transpose is literaly as it says. Get the complex conjugate of the matrix and transpose it. As illustrated below. Especialy try to get familiar with mathemtical symbols for this (final result). This is also called Hermitian conjugate.

The illustration below walks through both steps on a 3 x 3 example. The matrix A on the left holds entries of the form r + c i. The row number r sets the real part, and the column number c sets the imaginary part. The first arrow conjugates every entry, so each imaginary part changes its sign. The second arrow transposes the result, so row k becomes column k.

Figure 1. The conjugate transpose of A. Every entry is conjugated and moved to its mirror position across the main diagonal, and the four symbols at the bottom right all name the same result.

• Each entry moves and flips sign in one rule : take the entry in row c and column r of A. Its conjugate is the entry in row r and column c of A^H. For example, A has 1+2i in row 1, column 2, so A^H has 1-2i in row 2, column 1.
• The order of the two steps does not matter : conjugating first and transposing first give the same matrix. Conjugation acts on each entry by itself, and the transpose only moves entries around.
• Diagonal entries are only conjugated : an entry on the main diagonal stays where it is. So 1+i, 2+2i and 3+3i become 1-i, 2-2i and 3-3i.
• The shape changes as in an ordinary transpose : an m x n matrix becomes an n x m matrix. A column vector x therefore becomes a row vector x^H with conjugated entries.
• A real matrix gives the plain transpose : when every entry is real, the conjugate step changes nothing, so A^H equals A^T.

Which symbols stand for the same operation ?

The bottom right of Figure 1 lists four ways to write the same result. You will meet all of them, because each field has its own habit. Before you read a formula, check which symbol the author uses, and check what the author means by a star.

The star is the one to watch. In many signal processing books, x^* means only the complex conjugate of each entry, and the vector keeps its shape. In many linear algebra books, A^* means the full conjugate transpose. So the same symbol can stand for two different operations. A book usually states its convention in its notation list, and that list is worth reading before the first formula.

Two more names cause confusion. Some texts call A^H the adjoint of A. But older texts also use "adjoint" for the adjugate, which is the transposed cofactor matrix in the formula for the inverse. The two are unrelated. The word Hermitian also appears in two ways. A^H is the Hermitian conjugate of any matrix, while a Hermitian matrix is a special matrix that equals its own Hermitian conjugate. The section on Hermitian and unitary matrices below covers the second meaning.

• A^H is the unambiguous symbol : when you write your own formulas, use it rather than a star.
• A star needs a second look : check whether it means the conjugate only or the conjugate transpose. The two agree only for a scalar.
• Adjoint can mean two things : in a formula for an inverse it usually means the adjugate, not A^H.

What rules does the conjugate transpose follow ?

Formulas such as the zero forcing equalizer are derived by moving H through products, sums and inverses. The rules are the same as for the ordinary transpose, with one extra step for scalars. Let's list them, and then check the product rule on a small example.

• Applying it twice returns the matrix : (A^H)^H = A.
• It distributes over a sum : (A + B)^H = A^H + B^H.
• A scalar factor is conjugated : (cA)^H = c^*A^H. This is the extra step that the ordinary transpose does not have.
• A product reverses its order : (AB)^H = B^HA^H.
• It commutes with the inverse : (A^-1)^H = (A^H)^-1 for any invertible A.
• Determinant and trace are conjugated : det(A^H) is the conjugate of det(A), and trace(A^H) is the conjugate of trace(A).

The reversed order in the product rule is the one people forget. Here is a check with two 2 x 2 matrices. The wrong order gives a different matrix, so the rule is not only a convention.

B = [ 1   i ]      C = [ i   1   ]
    [ 2  -i ]          [ 0   2+i ]

BC          = [ i    2i   ]
              [ 2i   3-2i ]

(BC)^H      = [ -i   -2i  ]
              [ -2i  3+2i ]

C^H B^H     = [ -i   -2i  ]      same as (BC)^H
              [ -2i  3+2i ]

B^H C^H     = [ 2-i   4-2i ]     different, wrong order
              [ -1+i  1+2i ]

The same idea explains why a vector length uses H rather than T. Take x = [1+i, 2-i]^T. Then x^Tx = (1+i)² + (2-i)² = 3-2i, which is complex and cannot be a length. But x^Hx = |1+i|² + |2-i|² = 2 + 5 = 7, which is the squared length. For complex vectors, x^Hx is always real and never negative.

• Reverse the order in every product : (ABC)^H = C^HB^HA^H, exactly as for the ordinary transpose.
• Conjugate every scalar you pull out : forgetting this step gives a result that is correct only for real numbers.
• Use x^Hx for power and length : x^Tx is not a length when x is complex.

What are Hermitian and unitary matrices ?

Two classes of matrices are defined by how they behave under the conjugate transpose. You'll see them often, because a covariance matrix belongs to the first class, and a DFT matrix or a precoding matrix often belongs to the second. Each class has its own page on this site, so this section only states the definitions and connects them to A^H.

A matrix is Hermitian when A^H = A. Its diagonal entries are therefore real, and each off-diagonal entry is the conjugate of its mirror entry. Its eigenvalues are always real. The matrix A in Figure 1 is not Hermitian, but A + A^H always is. For that A, the sum is shown below, and its eigenvalues are 6+4√3, 0 and 6-4√3, which are about 12.93, 0 and -0.93. All three are real, as the theory says. The matrix A^HA is also always Hermitian, and its eigenvalues are never negative. See Hermitian Matrix for more.

A + A^H = [ 2      3+i    4+2i ]
          [ 3-i    4      5+i  ]
          [ 4-2i   5-i    6    ]

A matrix U is unitary when U^HU = I. Its inverse is then simply U^H, and it keeps the length of every vector, because (Ux)^H(Ux) = x^HU^HUx = x^Hx. The normalized N-point DFT matrix, with entries e^-j2πkn/N divided by √N, is a unitary matrix. See Unitary Matrix for more.

• Hermitian is the complex version of symmetric : a real Hermitian matrix is a symmetric matrix.
• Unitary is the complex version of orthogonal : a real unitary matrix is an orthogonal matrix.
• Both definitions use A^H, not A^T : with the plain transpose, a complex matrix would lose the real eigenvalues and the length-keeping property.

Where does it appear in wireless communication ?

In wireless systems the signals and channels are complex baseband values. So wherever a real-valued derivation uses a transpose, the complex version uses H. Here are the places you'll meet it most often, with links to the pages that cover each one.

• Received power : the power in a channel vector h is h^Hh = ||h||².
• Maximal ratio combining : with y = hs + n on N receive antennas, the receiver forms h^Hy = ||h||²s + h^Hn. The weights h^H undo the phase of each antenna path and weight each path by its amplitude. See Rx Diversity.
• Zero forcing : the equalizer is W = (H^HH)^-1H^H, the pseudo-inverse of a tall channel matrix H. See Zero Forcing Model.
• MMSE : for unit-power symbols and noise variance σ², the equalizer is W = (H^HH + σ²I)^-1H^H. See MMSE.
• SVD precoding : the channel is written as H = UΣV^H. Precoding with V and combining with U^H gives U^HHV = Σ, a set of parallel channels. See SVD Model.
• Covariance : the covariance of a zero-mean complex vector is R = E[xx^H], which is always Hermitian. See Covariance Matrix.

In every one of these formulas, a plain transpose would give a wrong answer for complex values, even though the matrix sizes still match. That is why a sign error in the imaginary part is the typical symptom when a T is written where an H belongs.

How do Matlab and Python compute it ?

Both tools have a short operator for the conjugate transpose and a separate one for the plain transpose. Mixing them up is one of the most common bugs in simulation code. The result has the right size, and only the signs of the imaginary parts are wrong, so nothing stops the program.

% Matlab / Octave
A  = [1+1i 1+2i; 2+1i 2+2i];
AH = A';            % conjugate transpose, same as ctranspose(A)
AT = A.';           % plain transpose, same as transpose(A)
p  = x' * x;        % squared length of a column vector x

# Python / numpy
import numpy as np
A  = np.array([[1+1j, 1+2j], [2+1j, 2+2j]])
AH = A.conj().T     # conjugate transpose
AT = A.T            # plain transpose, no conjugation
p  = np.vdot(x, x)  # vdot conjugates its first argument

You can reproduce Figure 1 with one line in either tool. In numpy, build the 3 x 3 matrix A and print A.conj().T. The result is the rightmost matrix of the figure, with 1-1j, 2-1j and 3-1j in its first row. In Matlab, A' prints the same values. If you print A.T in numpy instead, the first row is 1+1j, 2+1j and 3+1j. That is the transpose with the signs of the imaginary parts left unchanged.

• In Matlab the apostrophe already conjugates : A' is A^H. Use A.' when you want the transpose alone.
• In numpy .T never conjugates : write A.conj().T, or A.T.conj(), for A^H.
• Inner product functions conjugate one argument : Matlab dot(x,y) and numpy vdot(x,y) conjugate the first argument, while numpy dot and the @ operator conjugate nothing.