Uiua, 4 bytes

≍¯⊸⍉

Try it!

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

Vyxal, 3 bytes

∩N⁼

Try it Online!

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

Ruby 2.7, 40 bytes

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

Try it online!

J, 5 bytes

--:|:

Attempt This Online!

--:|:
-      NB. negate
   |:  NB. transpose
 -:    NB. match?

Nekomata + -e, 3 bytes

Ť_=

Attempt This Online!

Ť     Transpose
 _    Negate
  =   Check equality

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

k, 7 bytes

Similar to the APL solution. Compare (x~) original matrix against negated transpose (-+x}

{x~-+x}

J-uby, 28 bytes

Port of Razetime's Ruby answer.

:=~&(:transpose|:*&(:*&:-@))

Attempt This Online!

Explanation

:=~ & (:transpose | :* & (:* & :-@))

       :transpose |                   # Transpose input, then
                    :* & (        )   # Map with
                          :* & :-@    #   Map with negate
:=~ & (                            )  # Equal to input

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.

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

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.

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?

Google Sheets, 90 88 41

(Now with lambdas)

Closing parens discounted.

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

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.

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.

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)

Jelly, 3 bytes

N⁼Z

Try it online!

Posting before caird coinheringaahing finds this question.

Husk, 5 bytes

§=T†_

Try it online!

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?
)

Julia 1.0, 9 bytes

A->A==-A'

A straightforward anonymous function checking the equality.

Try it online!

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.

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.

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

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?

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

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!

R, 23 bytes

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

Try it online!

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

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

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

Pyth, 5 bytes

qC_MM

Try it online!

Explanation

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

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

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

Python 2, 45 bytes

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

Try it online!

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 ⍉.