Antisymmetry of a Matrix

Question

A matrix is antisymmetric, or skew-symmetric, if its transpose equals its negative.

The transpose of a matrix can be obtained by reflecting its elements across the main diagonal. Examples of transpositions can be seen here:

\$\begin{pmatrix}11&12&13\\21&22&23\end{pmatrix}\rightarrow\begin{pmatrix}11&21\\12&22\\13&23\end{pmatrix}\$

\$\begin{pmatrix}11&12&13\\21&22&23\\31&32&33\end{pmatrix}\rightarrow\begin{pmatrix}11&21&31\\12&22&32\\13&23&33\end{pmatrix}\$

This matrix is antisymmetric because it equals its transpose when multiplied by -1:

\$\begin{pmatrix}0&2&-1\\-2&0&0\\1&0&0\end{pmatrix}\$

All antisymmetric matrices exhibit certain characteristics:

• Antisymmetry can only be found on square matrices, because otherwise the matrix and its transpose would be of different dimensions.

• Elements which lie on the main diagonal must equal zero because they do not move and consequently must be their own negatives, and zero is the only number which satisfies \$x=-x\$.

• The sum of two antisymmetric matrices is also antisymmetric.

The Challenge

Given a square, non-empty matrix which contains only integers, check whether it is antisymmetric or not.

Rules

• This is code-golf so the shortest program in bytes wins.

• Input and output can assume whatever forms are most convenient as long as they are self-consistent (including output which is not truthy or falsy, or is truthy for non-antisymmetry and falsy for antisymmetry, etc).

• Assume only valid input will be given.

Test Cases

In:
1 1 1
1 1 1
1 1 1

Out: False


In:
 0 0 1
 0 0 0
-1 0 0

Out: True


In:
0 -2
2  0

Out: True

Answer 1

APL (Dyalog Unicode), 3 bytes

-≡⍉

Try it online!

This is exactly an APLcart entry on "antisymmetric". Basically it checks if the input's negative - matches ≡ the input's transpose ⍉.

Answer 2

Python 2, 45 bytes

lambda A:A==[[-x for x in R]for R in zip(*A)]

Try it online!

Answer 3

R, 23 bytes

function(m)!any(m+t(m))

Try it online!

Checks whether there are any non-zero elements in \$M+M^T\$.

Answer 4

Brachylog, 5 bytes

5 bytes seems to be the right length for this (unless you're Jelly). Actually, this would be three bytes if Brachylog implicitly vectorized predicates like negation.

\ṅᵐ²?

Try it online!

Explanation

\      Transpose
 ṅᵐ²   Map negation at depth 2
    ?  Assert that the result is the same as the input

Answer 5

C (gcc), 67 64 bytes

-3 thanks to AZTECCO

i,j;f(m,s)int**m;{for(i=j=0;i=i?:s--;)j|=m[s][--i]+m[i][s];m=j;}

Try it online!

Returns 0 if the matrix is antisymmetric, and a nonzero value otherewise.

Answer 6

Octave, 19 bytes

@(a)isequal(a',-a);

Try it online!

The semicolon doesn't need to be there, but it outputs the function otherwise, so I'll take the one-byte hit to my score for now.

Explanation

It's pretty straightforward - it checks to see if the matrix of the transpose is equal to the negative matrix

Answer 7

JavaScript (ES6), 42 bytes

Returns false for antisymmetric or true for non-antisymmetric.

m=>m.some((r,y)=>r.some((v,x)=>m[x][y]+v))

Try it online!

Answer 8

Io, 67 bytes

method(~,~map(i,\,\map(I,V,V+x at(I)at(i)))flatten unique==list(0))

Try it online!

Explanation

For all a[x][y], it checks whether all a[x][y]+a[y][x]==0.

method(~,                                 // Input x.
    ~ map(i,\,                            // Map all x's rows (index i):
        \ map(I,V,                        //     Foreach the rows (index I):
            V+x at(I)at(i)                //         x[i][I] + x[I][i]
        )
    ) flatten                             // Flatten the resulting list
    unique                                // Uniquify the list
    ==list(0)                             // Does this resulting list *only* contain the item 0?
)

Answer 9

Pyth, 5 bytes

qC_MM

Try it online!

Explanation

qC_MM
q      : Check if input equals
 C     : Transpose of
  _MM  : Negated input

Answer 10

MATL, 5 bytes

!_GX=

Try it online!

Explanation

!_GX=
        // Implicit input on top of stack
!       // Replace top stack element with its transpose
 _      // Replace top stack element with its negative
  G     // Push input onto stack
   X=   // Check for equality

Answer 11

Japt, 5 bytes

eUy®n

Try it

e       compare input with :
 Uy       columns of input
   ®n     with each element negated

Previous version ÕeËËn didn't work, corrected using the ® symbol

Answer 12

Charcoal, 10 bytes

⁼θＥθＥ豧λκ

Try it online! Link is to verbose version of code. Outputs a Charcoal boolean, i.e. - if the matrix is antisymmetric, nothing if not. Explanation:

  Ｅθ        Map over input matrix rows (should be columns, but it's square)
    Ｅθ      Map over input matrix rows
       §λκ  Cell of transpose
      ±     Negated
⁼θ          Does matrix equal its negated transpose?

Answer 13

Wolfram Mathematica, 20, 7 bytes

There is a built-in function for this task:

AntisymmetricMatrixQ

But one can simply write a script with less byte counts:

#==-#ᵀ&

The ᵀ character, as it is displayed in notebooks, stands for transpose. But if you copy this into tio, it won't be recognized because these characters are only supported by Mathematica notebooks.

Answer 14

Julia 1.0, 9 bytes

A->A==-A'

A straightforward anonymous function checking the equality.

Try it online!

Answer 15

Husk, 5 bytes

§=T†_

Try it online!

Answer 16

Google Sheets, 90 88 41

(Now with lambdas)

Closing parens discounted.

Named Functions (name, args, and formula text all count):

Name	args	Formula
P	a, b	a+b
Q	a	MAP(a,TRANSPOSE(a),P)

Formula:

=SUM(Q(A1:C3))

No, I cannot currently use ADD instead of P as it is not a lambda.

How it Works:

Add the matrix to its transpose. If the resulting matrix is all 0's, then the sum of all elements is 0, which means we the two are equal.

Return 0 if equal, some positive number otherwise.

Answer 17

Haskell, 40 bytes

(==)<*>foldr(zipWith(:).map(0-))z
z=[]:z

Try it online!

Uses this tip for shorter transpose and the idiom of (==)<*> to check invariance under an operation.

Answer 18

Haskell, 49 47 bytes

import Data.List 
f x=x==transpose(map(0-)<$>x)

Try it online!

• saved 2 thanks to @Unrelated String

My first Haskell.
Function tacking a matrix and checking if input is equal to input mapped to (0-value) and transposed

Answer 19

Scala, 32 bytes

l=>l.transpose==l.map(_.map(-_))

Finally, something that Scala has a builtin for!

The function's pretty straightforward - it compares the transpose of a List[List[Int]](doesn't have to be a List, could be any Iterable) to the negative, found by mapping each list inside l and using - to make it negative.

Try it in Scastie

Answer 20

Ruby 2.7, 40 bytes

->a{a==a.transpose.map{|r|r.map{|c|-c}}}

Try it online!

Answer 21

Pip, 5 bytes

Z_=-_

A function submission; pass a nested list as its argument. Try it online!

Explanation

Z_     The argument, zipped together
  =    Equals
   -_  The argument, negated

Answer 22

gorbitsa-ROM, 8 bytes

r1 R A1 B0 T

This is an awful abuse of rule

Input and output can assume whatever forms are most convenient.

If input takes form of "arr[i][j] arr[j][i]", the problem becomes "is sum = 0?".
This code takes pairs of values and outputs their sum if it's not 0

Thus if you provide matrix as previously mentioned pairs, code will return some value for not-anti-symmetric ones and will not return anything for anti-symmetric ones.

r1 R A1 B0 T
r1           #store first number
   R         #read second number
     A1      #add first number
        B0   #if sum==0, jump to the beginning
           T #else output the sum

Answer 23

Jelly, 3 bytes

N⁼Z

Try it online!

Posting before caird coinheringaahing finds this question.

Answer 24

Java (JDK), 89 87 86 bytes

• -2 bytes thanks to Calculuswhiz!

m->{int i=0,j,r=1;for(;++i<m.length;)for(j=0;++j<i;)r=m[i][j]!=-m[j][i]?0:r;return r;}

Try it online!

Returns 0 for false and 1 for true.

Answer 25

Nekomata + -e, 3 bytes

Ť_=

Attempt This Online!

Ť     Transpose
 _    Negate
  =   Check equality

Answer 26

Vyxal, 3 bytes

∩N⁼

Try it Online!

∩   # Transpose
 N  # Negate
  ⁼ # Equal to original?

Answer 27

Uiua, 4 bytes

≍¯⊸⍉

Try it!

Does the ¯ negated ⍉ transposition ≍ match the input (⊸)?

Answer 28

05AB1E, 3 bytes

ø(Q

Try it online or verify all test cases.

Explanation:

ø    # Zip/transpose the (implicit) input-matrix; swapping rows/columns
 (   # Negate each value in this transposed matrix
  Q  # And check if it's equal to the (implicit) input-matrix
     # (after which the result is output implicitly)

Answer 29

Factor + math.matrices, 19 bytes

[ dup flip mneg = ]

Try it online!

• dup make a copy of the input
• flip transpose it
• mneg negate it
• = are they equal?

Answer 30

Raku, 26 bytes

{none flat $_ »+«[Z] $_}

Try it online!

• $_ is the input matrix, in the form of a list of lists of integers.
• [Z] $_ is the transpose of the input matrix.
• »+« adds the input matrix to its transpose.
• flat flattens the matrix into a single list of numbers.
• none converts that list of numbers into a junction which is true if and only if none of the numbers is truthy, that is, nonzero.

The none-junction is returned. It is truthy only if adding the matrix to its transpose results in a matrix containing all zeroes.