vector transpose equality

[uniment]

julia> @show [1;2;3]  == [1 2 3]'
       @show [1;2;3]' == [1 2 3]''
       @show [1 2 3]  == [1;2;3]'
       @show [1 2 3]' == [1;2;3]''
[1; 2; 3] == ([1 2 3])' = false
([1; 2; 3])' == (([1 2 3])')' = true
[1 2 3] == ([1; 2; 3])' = true
([1 2 3])' == (([1; 2; 3])')' = false

[jakobnissen]

That seems right to me. What's the issue?

[barucden]

I think this boils down to the fact that a single-column matrix is never equal to a (column) vector:

julia> X = ones(Int, 3, 1)
3×1 Matrix{Int64}:
 1
 1
 1

julia> X == X[:, 1]
false

[uniment]

@jakobnissen maybe i'm rusty but i'm unaware of any mathematical objects x and y for which x = y' but x' ≠ y''

[adienes]

julia> [1,2,3] == [1,2,3]''
true

julia> [1 2 3] == [1 2 3]''
true

[adienes]

sorry, I misread your comment. I do actually see the core issue, which is that

julia> [1 2 3] == [1,2,3]'
true

basically since LinearAlgebra.Adjoint <: AbstractArray it uses the AbstractArray fallbacks for == (and hash of course) which check axes and elements. arguably, Adjoints should not equal non-adjoint arrays of the same shape, although I would bet that ends up being pretty breaking.

either way though, this would be an issue for LinearAlgebra not Base

[uniment]

arguably, Adjoints should not equal non-adjoint arrays of the same shape

no this behavior is desired. Adjoint is just a lazy view representing the conjugate transposed matrix, and it's desirable that a lazy view should equal a realized matrix whose dimensions and values are the same:

julia> [1 2 3 4; 5 6 7 8]' == [1 5; 2 6; 3 7; 4 8]
true

as @barucden pointed out, the underlying issue is that a Vector is not equal to any Matrix despite being transposable to an object that equals a Matrix:

julia> [1;2;3] == [1;2;3;;]
false

julia> [1;2;3]' == [1;2;3;;]' == [1 2 3]
true

since transposing is understood to create a matrix from another matrix, the fact that a Vector can be transposed to an object that equals a Matrix implies that it is considered to "be" a matrix, or at least to be promotable to one, but equality has a different opinion of the matter.

if a vector could equal a matrix, then for consistency across tensor ranks we would want these also to evaluate to true:

julia> [1;2;3] == [1;2;3;;]
false

julia> [1;2;3;;] == [1;2;3;;;]
false

julia> [1;2;3;;;] == [1;2;3;;;;]
false

the options seem to be:

1. allow different-rank tensors to be equal as suggested above, as long as their entries are in the same dimensions and their values are equal (would it break anything?)
2. make adjoint for Vector undefined (would definitely break things)
3. leave unchanged, understanding the special behavior of Vector to effectively promote to Matrix for transpose but not for equality, and live with the fact that there exist objects x,y in the language for which x == y and x' != y' (and x'' == y'', x''' != y''', x'''' == y'''', etc.)

[stevengj]

Adjoint is just a lazy view representing the conjugate transposed matrix

This is not correct.

We intentionally defined [1,2,3]' as a funny kind of object as a compromise between the two viewpoints of "row vectors" (#42):

1. It acts as a covector (linear form) when multiplied on the right by vectors (or matrices), producing a scalar (or covector, respectively): [1,2,3]' * [1,2,3] == 14 (scalar), whereas [1 2 3] * [1,2,3] == [14] (vector), so [1 2 3] * [1,2,3] == [1,2,3]' * [1,2,3] returns false; similarly, when multiplied on the right by a 3x3 matrix ala [1,2,3]' * rand(3,3) it produces another covector (Adjoint)
2. In many other contexts, e.g. when added to a 1-row matrix, it acts like a 1-row matrix, e.g. [1 2 3] + [1,2,3]' gives [2 4 6], and size([1,2,3]') == (1,3), and so on.

On the other hand, column vectors (1d arrays) like [1,2,3] also have a funny double meaning, e.g. they can be added to 1-column matrices to produce 1-column matrices. So, my feeling is that we have three sensible options:

1. do nothing, leave the Adjoint case kind of inconsistent in recognition that the transpose of a column vector has an uncomfortable "dual" meaning (no pun intended)
2. or change [1 2 3] == [1,2,3]' to return false (since they behave differently under multiplication)
3. or change [1,2,3] == [1;2;3;;] to return true (might have been debated at one point? I can't remember)

Of course, either of the latter two options might be breaking, so at this point our only practical option may be (1).

[aravindh-krishnamoorthy]

3. leave unchanged, understanding the special behavior of Vector to effectively promote to Matrix for transpose but not for equality, and live with the fact that there exist objects x,y in the language for which x == y and x' != y' (and x'' == y'', x''' != y''', x'''' == y'''', etc.)

I understand where you're coming from. These shape transformations, x = y $\implies$ x' = y' apply to matrices, and any variable of type Matrix must indeed satisfy them. If not, this would be a bug.

But, I guess your expectation that vectors satisfy the above shape transformations arises because, in many programming languages, a vector is seen as an (efficient) $1$-column matrix.

Sadly, the compromise chosen by Julia, which results in [1 2 3] == [1;2;3]', and Julia documentation, which reinforces the view that transpose(vector) is similar to a $1\times n$ matrix, cause this confusion. Julia solution is neither here nor there.

Personally, if I'd like a variable to have a shape, I'd probably pick a Matrix type. Also, I'd try to avoid transpose or adjoint on a vector, simply use dot (like Mathematica), and not concern myself on the actual implementation details of reusing * for the dot product.