In general for complex matrices, the transpose alone or the conjugate alone have very limited meaning and utility. You almost always want to talk about the Hermititan adjoint for any practical matters.
One might then wonder why? Well, the way I like to think about it is that the reason is actually the same reason that transpose is recursive in julia. I.e. if I have the block matrix,
julia> M = reshape([[1 2; 3 4], [5 6; 7 8], [9 0; 1 2], [3 4; 5 6]], 2, 2)
2×2 Matrix{Matrix{Int64}}:
[1 2; 3 4] [9 0; 1 2]
[5 6; 7 8] [3 4; 5 6]
taking the transpose of this matrix also takes the transpose of the elements:
julia> transpose(M)
2×2 transpose(::Matrix{Matrix{Int64}}) with eltype Transpose{Int64, Matrix{Int64}}:
[1 3; 2 4] [5 7; 6 8]
[9 1; 0 2] [3 5; 4 6]
The reason we take this transpose recursively is that the block matrix M can somewhat straigtforwardly be reinterpreted as a regular matrix N:
julia> N = [[1 2; 3 4] [5 6; 7 8]
[9 0; 1 2] [3 4; 5 6]]
4×4 Matrix{Int64}:
1 2 5 6
3 4 7 8
9 0 3 4
1 2 5 6
with the same algebraic properties. For instance,
julia> M^2
2×2 Matrix{Matrix{Int64}}:
[58 22; 86 38] [64 78; 104 126]
[40 26; 58 22] [74 90; 64 78]
julia> N^2
4×4 Matrix{Int64}:
58 22 64 78
86 38 104 126
40 26 74 90
58 22 64 78
Hence, we need the transpose of N and M to match if they’re going to share algebraic properties in a ‘faithful’ way.
What does this have to do with complex numbers? Well, we typically treat complex numbers as their own fundamental algebraic objects, but we actually do have the freedom to reinterpret them in terms of matrix algebra over real numbers. Observe:
julia> 𝟙 = [1 0; 0 1];
julia> 𝕀 = [0 1; -1 0];
julia> 𝟙^2 == 𝟙 # just like 1^2 == 1
true
julia> 𝕀^2 == -𝟙 # just like im^2 == -1
true
and all sorts of things ‘just work’:
julia> exp(𝕀 * π) ≈ -𝟙 # just like exp(im*π) ≈ -1 see https://en.wikipedia.org/wiki/Euler%27s_identity
true
Now a natural question becomes: what is the equivalent of the complex conjugate in this representation? It’s exactly the transpose!
julia> transpose(𝟙) == 𝟙
true
julia> transpose(𝕀) == -𝕀 # conj(im) == -im
true
e.g.
julia> z = 3 - 4im;
julia> √(z * conj(z)) # absolute value of z
5.0 + 0.0im
julia> Z = 3𝟙 - 4𝕀;
julia> √(Z*transpose(Z)) ≈ 5𝟙
true
So for the same reason that it’s very natural for transpose to be recursive on matrices, transpose really is only meaningful from an algebraic point of view if it is also accompanied by a complex conjugate.
Hence, in julia we don’t really use transpose much for linear algebra, and instead always use the algebraically more meaningful adjoint.