[Question]
  [
**Note that this challenge requires no handling or understanding of complex numbers.**
Given a non-empty square matrix where every element is a two-element (Re,Im) integer list, determine (giving any truthy/falsy values or any two consistent values) whether this represents a Hermitian matrix.
Note that the input is a 3D array of integers; not a 2D array of complex numbers. If your language cannot take a 3D array directly, you may take a flat list (and the n√ón or n√ón√ó2 shape if that helps).
A matrix is [Hermitian](https://en.wikipedia.org/wiki/Hermitian_matrix) if it equals its own [conjugate transpose](https://en.wikipedia.org/wiki/Conjugate_transpose). In other words, if you flip it across its top-left to bottom-right diagonal and negate the second element of all the two-element leaf-lists, it is identical to the input matrix. Note that the order of flipping and negating is irrelevant, so you may negate first, and flip afterwards.
### Walk-though example
This example uses JSON with superfluous white-space to ease reading:
```
[[ [2, 0] , [2, 1] , [4, 0] ],
 [ [2,-1] , [3, 0] , [0, 1] ],
 [ [4, 0] , [0,-1] , [1, 0] ]]
```
Transpose (flip across NW‚ÄîSE diagonal):
```
[[ [2, 0] , [2,-1] , [4, 0] ],
 [ [2, 1] , [3, 0] , [0,-1] ],
 [ [4, 0] , [0, 1] , [1, 0] ]]
```
Negate second elements of leaf-lists:
```
[[ [2, 0] , [2, 1] , [4, 0] ],
 [ [2,-1] , [3, 0] , [0, 1] ],
 [ [4, 0] , [0,-1] , [1, 0] ]]
```
As this is identical to the input, the matrix is Hermitian.
## Test cases
### Hermitian
`[[[2,0],[2,1],[4,0]],[[2,-1],[3,0],[0,1]],[[4,0],[0,-1],[1,0]]]`
`[[[1,0],[2,0]],[[2,0],[1,0]]]`
`[[[1,0],[2,-3]],[[2,3],[1,0]]]`
`[[[42,0]]]`
### Non-Hermitian
`[[[2,0],[2,1],[4,0]],[[2,-1],[3,0],[0,1]],[[4,0],[0,-1],[1,-1]]]`
`[[[0,1],[0,2]],[[0,2],[0,1]]]`
`[[[1,0],[2,3]],[[2,3],[1,0]]]`
`[[[3,2]]]`
  
[Answer]
# R, ~~71~~ ~~48~~ 47 bytes
```
function(A)all(Conj(t(B<-A[,,1]+A[,,2]*1i))==B)
```
Takes a 3D array of real numbers, make a 2D array of imaginary numbers, transpose, conjugate and compare.
Thanks to [@Giuseppe](https://codegolf.stackexchange.com/users/67312) for reducing the byte count by an astounding 23 bytes, and to [@Vlo](https://codegolf.stackexchange.com/users/30693) for the final 1!
[Try it online!](https://tio.run/##K/qfZqP7P600L7kkMz9Pw1EzMSdHwzk/L0ujRMPJRtcxWkfHMFYbRBnFahlmamra2jpp/k/TSCwqSqzUSNYw0jHSMQFiYx0DIG2gYwjEuoZoDE2dlMxc22QNY6AyI01NTS6EfhMjhLQhUC2aNDHG6xriMR8kgG78fwA "R ‚Äì Try It Online")
Example:
```
> A <- array(c(2,2,4,2,3,0,4,0,1,0,-1,0,1,0,-1,0,1,0),dim=c(3,3,2))
> A
, , 1
     [,1] [,2] [,3]
[1,]    2    2    4
[2,]    2    3    0
[3,]    4    0    1
, , 2
     [,1] [,2] [,3]
[1,]    0    1    0
[2,]   -1    0    1
[3,]    0   -1    0
> f <- function(A)all(Conj(t(B<-A[,,1]+A[,,2]*1i))==B)
> f(A)
[1] TRUE
```
[Answer]
# [Octave](https://www.gnu.org/software/octave/), ~~39~~ ~~34~~ 31 bytes
```
@(x)(y=x(:,:,1)+j*x(:,:,2))==y'
```
[Try it online!](https://tio.run/##JcmxCoAgFEbhvRfp3voTtabkQu8RDSE5tLREaC9vStvHOZe/9@fIQZRSeaHIlCTSjBmG@7P7aZlFUpujrBYWk7MYod0EDbO5JslaUMJganEaFWW84vebRkQkbgK9nD8 "Octave ‚Äì Try It Online")
Saved 3 bytes thanks to Luis Mendo who informed me about the clarifications in the challenge text.
### Explanation:
In MATLAB and Octave, `'` is the conjugate complex transpose, not the "regular" transpose.
We create a variable `y` inline that's the first layer of the 3D matrix plus the second layer multiplied with the complex unit `j`, i.e. a complex matrix where the real term is the first "layer", and the imaginary is the second "layer". We then check if it equals itself complex conjugate transposed. 
This will output a matrix containing only `1` if true, and a matrix containing at least one `0` if false. These are considered true and false in Octave [(Proof)](https://tio.run/##y08uSSxL/f8/M00h2lBHAYgMYnUUUjKLCzTU4QIKmcUKJUWlqeqaOgqpOcWp2OTTEoESYAV5KVwI0wzRTTMkYJohhmn//wMA).
[Answer]
# [Python 2](https://docs.python.org/2/), 50 bytes
```
lambda m:[[[a,-b]for a,b in l]for l in zip(*m)]==m
```
[Try it online!](https://tio.run/##rU67CgMhEOzvKyzPoOCrCvglFwslSAT15Lgm@XmzioEQjqRJs7OzMztMue@3NYvq9aVGm9zVonRelsUS6oxfN2SJQyGj2Els6yOU@ZSw0TrVsoW8Iz/DhyDMEJgcpoIdABhtVHaJgdSOarAu8eY0eHoL4iPoFcG@26gcPnnsU2Lcpj@UBfiIZz2DEdHtDcfzcdsfZWXLMbg@AQ "Python 2 ‚Äì Try It Online")
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), ~~22~~ ~~15~~ ~~9~~ 7 bytes
```
‚çâ‚â°‚ä¢‚àò-\¬®
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///P@1R24RHvZ2POhc@6lr0qGOGbsyhFUBRBQ1jBeNHvVs0jBQMNIGEoaaGCYR1aD2QbQxiG8BFDSCihkC2JhdQr5GCEUivIUQHjMAhfWi9MYgyRlJgqGAIVPCoq8kEpJGLXNeAKGQLwUqghBGEhcU9uF0DtMhIUxMA "APL (Dyalog Unicode) ‚Äì Try It Online")
Tacit prefix function.
Thanks to Ad√°m for 7 bytes on the Dfn, and to both Ad√°m and ErikTheOutgolfer for ~~putting up with my stupidity~~ helping me find the tacit version.
Thanks to ngn for 2 bytes on the tacit version.
### How?
```
‚çâ‚â°‚ä¢‚àò-\¬® ‚çù Anonymous tacit function.
      ¬® ‚çù Apply to each element of the argument:
     \  ‚çù Cumulative reduction, using
  ‚ä¢‚àò-   ‚çù Ignore the first element, then negate the second
 ‚â°      ‚çù And match
‚çâ       ‚çù To the argument's transposition.
```
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), ~~45~~ ~~34~~ ~~33~~ ~~26~~ ~~21~~ 18 bytes
* Saved eleven bytes thanks to [JungHwan Min](https://codegolf.stackexchange.com/users/60043/junghwan-min).
* Saved a byte thanks to [Martin Ender](https://codegolf.stackexchange.com/users/8478/martin-ender).
* Saved seven bytes thanks to [alephalpha](https://codegolf.stackexchange.com/users/9288/alephalpha).
* Saved five bytes thanks to [alephalpha](https://codegolf.stackexchange.com/users/9288/alephalpha).
* Saved three bytes.
```
#==#Ôèâ&[#.{1,I}]&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2b7X9nWVvl9f6datLJetaGOZ22s2v@Aosy8Eoc0h@rqaiMdg1odIGkIJE2AbCAF5OmCuMZgKQOgFEjQBMoDSxmCVNZyIZljCDUHZoIBXlW6xlBlxliVmRghCynp6uoqcVHBzUAK1R4DsBEGOkZg1SAaqhero/G72RhkSu1/AA "Wolfram Language (Mathematica) ‚Äì Try It Online")
[Answer]
# Java 8, ~~137~~ ~~136~~ ~~134~~ ~~126~~ ~~119~~ 116 bytes
```
m->{int r=1,l=m.length,i=l*l,j,k;for(;i-->0;)r=m[j=i/l][k=i%l][0]!=m[k][j][0]|m[j][k][1]!=-m[k][j][1]?0:r;return r;}
```
-3 bytes thanks to *@ceilingcat*.
Returns `1` if Hermitian, `0` otherwise.
**Explanation:**
[Try it online.](https://tio.run/##tVA9b4MwEN3zK9xIlaA1hI9MQU63bs2SbojBJU5iMCYyJlVE@e30DE63SlXaCnPn9@7Dd6@gZ@rVJyaLXTnkgjYNeqFcdjOEuNRM7WnO0MbAkUC5AzbNzIcqNwG@hx9Oo6nmOdogiQgaKm/dmXRFQixI5QsmD/qIOREPAhe4TPa1chLueesgcRWp0oLwhcjSkvB7cEF2B1yZpYW5f1TGAwqB9q58mD0FK5UoplslkUr6IZkmObVvAiaxA51rvkMVrORsteLykGbUndZZLNCravXxshrh9tJoVvl1q/0TJGpH@rkj2Tv6WrjruggHPQYbgl3CHRwgz8B4DAUQMuTSojEUmszefZzj@SjZDx8L7WPXZ4Lft/Ji2yu@vdcymuq@qRHSsREQ@JmKhv2rwJO@kHDDJlN1gKOxo/G2/@0C/4G@sZnHytvP@uET)
```
m->{                 // Method with 3D integer-array as parameter and boolean return-type
  int r=1,           //  Flag-integer `r`, starting at 1
      l=m.length,    //  The size of the 3D input array
      i=l*l,j,k;     //  Index-integers
  for(;i-->0;)       //  Loop over the rows and columns
    r=m[j=i/l][k=i%l][0]!=m[k][j][0]
                     //   If the first numbers diagonally aren't equal,
      |m[j][k][1]!=-m[k][j][1]?
                     //   or the second numbers aren't negatives of each other:
       0             //    Set the flag `r` to 0
      :              //   Else:
       r;            //    Leave the flag `r` the same
  return r;}         //  Return the flag `r`
```
[Answer]
# [J](http://jsoftware.com/), 14 bytes
```
[:(+-:|:)j./"1
```
[Try it online!](https://tio.run/##JYs7CoAwEET7nGIIgoq/XbVa9CQWFmKQQLCw1bPHjTI8Bt4wProLs4CgxEWKqpFbSt92lmNpbIvcpT1HjUfgLmP27TgxWUZIw6DpkSmkMMavV1ZNml9QEgz6vw4hvg)
## Explanation
```
[:(+-:|:)j./"1  Input: 3d array
         j./"1  Reduce by complex combine at rank 1
[:              Cap, operate on the 2d array of complex values
   +              Conjugate
      |:          Transpose
    -:            Match?
```
[Answer]
# [Haskell](https://www.haskell.org/), 50 bytes
*-7 bytes thanks to H.PWiz.*
```
(==)<*>map(map((0-)<$>)).foldr(zipWith(:))e
e=[]:e
```
[Try it online!](https://tio.run/##y0gszk7NyfmfZhvzX8PWVtNGyy43sUADhDUMdDVtVOw0NfXS8nNSijSqMgvCM0syNKw0NVO5Um2jY61S/@cmZuYp2CoUFGXmlSioKKQpRAOhhpGOgoGmDpg2BNEmIL5CLJcCOtCBqNYFqzKG6jIA6cKp2gSuCqLLEGK2Quz/f8lpOYnpxf91kwsKAA "Haskell ‚Äì Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~6~~ 5 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
Z√ó√ò+‚Åº
```
A monadic link returning `1` for a Hermitian input and `0` otherwise.
**[Try it online!](https://tio.run/##y0rNyan8/z/q8PTDM7QfNe75//9/dLRCtJGOgkGsgg6YYQhmmIBFYnW4FMDSuhBRY5g6A7A6qLQJQhSqzhCiOxYA "Jelly ‚Äì Try It Online")**
### How?
```
Z√ó√ò+‚Åº - Link: list of lists of lists, M
Z     - transpose
  √ò+  - literal = [1,-1]
 √ó    - multiply (vectorises)
    ‚Åº - equal to M?
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 9 bytes
```
√∏ŒµŒµX¬Æ‚Äö*]Q
```
[Try it online!](https://tio.run/##MzBNTDJM/f//8I5zW89tjTi07lHDLK3YwP//o6OjjXQMYnWApCGQNAGygRSQpwviGoOlDIBSIEETKA8sZQiiYmMB "05AB1E ‚Äì Try It Online")
**Explanation**
```
√∏           # transpose
 Œµ          # apply to each 2-d array
  Œµ         # apply to each pair
   X¬Æ‚Äö*     # multiply by [1,-1]
       ]    # end apply(s)
        Q   # compare to input for equality
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 46 bytes
```
->m{m.transpose.map{|l|l.map{|a,b|[a,-b]}}==m}
```
[Try it online!](https://tio.run/##pU67DsMgENvzFf0AiHit9EfSG0BqptCikAxV4NvJQamqSlGWMpzPZ2N5Xu0rj/qW6dVtrl9m8wj@Ge69M36LU5zeiyE2DoZQCylp7VL26xIu44BPEAYEJ8epcEdARguVVWIolaNqrEq8OAG6bw5vOZ8EduqistnkoU2Jdur@L4rwG85qBCOiugu2v4dNz4vKkgKQdw "Ruby ‚Äì Try It Online")
Port of my [Python answer](https://codegolf.stackexchange.com/a/156752/38592)
[Answer]
# [Perl 5](https://www.perl.org/), -a0 48 bytes
Old counting: 50 bytes (`+2` for `a0`). Not bad for a language that has no builtin transpose (I'm not jealous at all, no sirree)
Give the input matrix on STDIN with `,` between the real and imaginary part, so e.g.:
```
2,0 2,1 4,0
2,-1 3,0 0,1
4,0 0,-1 1,0
```
Will print `1` for hermitian, nothing otherwise
```
#!/usr/bin/perl -a0
say@F~~[map/(\S+,)(\S+)/gc?$1.-$2:(),(/.+/g)x@F]
```
[Try it online!](https://tio.run/##K0gtyjH9X1qcqmCqZ2igZ2D9vzix0sGtri46N7FAXyMmWFtHE0Rq6qcn26sY6umqGFlpaOpo6Otp66drVji4xf7/b6RjoGCkY6hgomPAZaSja6hgDBQw0DHkMgHTQAFDoMy//IKSzPy84v@6iQYA "Perl 5 ‚Äì Try It Online")
[Answer]
# [Husk](https://github.com/barbuz/Husk), 7 bytes
```
=¬πmm·πÄ_T
```
[Try it online!](https://tio.run/##yygtzv7/3/bQztzchzsb4kP@//8fHa1hpGOgqQMkDYGkCZAdqwMS0wVxjcFSBkApkKAJlAeWMgSpjAUA "Husk ‚Äì Try It Online")
# How?
Note that `‚Ä†` should work instead of `mm`
, but [there's an annoying bug](https://chat.stackexchange.com/transcript/message/43073150#43073150) that prevents me from using it :(
```
=¬πmm·πÄ_T ‚Äì Full program. Takes input from Command line args, as a list of lists of tuples.
  m   T ‚Äì For each list in the input's tranpose...
   m·πÄ_  ‚Äì ... Negate the last value of each tuple they contain.
=¬π      ‚Äì Check whether this is the same as the input.
```
[Answer]
# JavaScript (ES6), 53 bytes
*Saved 2 bytes thanks to @Neil*
Returns `false` for Hermitian or `true` for non-Hermitian.
```
m=>m.some((r,y)=>r.some(([a,b],x)=>m[x][y]!=a+[,-b]))
```
[Try it online!](https://tio.run/##tVFBDoMgELz7i54qKRgUr3ruqR8gHNBiYyPQqGn09XYhmLRpY7z0ssvszA5MuMunHOq@fYzE2KtammLRRamTwWoVxz2eUVH2AXGJK4EnmGg@CT6LQyFPHJNKILTU1gy2U0lnb/GRn1Wv27GVRhxR9E41Mec8w1RgqCnUHM7QABEHmacoUG6YB@Sp1Cnhqm@/NPitTnSXmrAgZ5vyPFup6DPjxRryn5zQfr@FeiuKM7/levDYDLovJ3Ou7idf "JavaScript (Node.js) ‚Äì Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~107~~ ~~103~~ 100 bytes
* Saved four bytes thanks to [Steadybox](https://codegolf.stackexchange.com/users/61405/steadybox); golfed `A[0]` to `*A` twice.
* Saved three bytes thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat).
```
j,k,r;f(A,s)int***A;{for(r=0,j=s;j--;)for(k=s;k--;)r|=*A[j][k]-*A[k][j]|A[j][k][1]+A[k][j][1];A=!r;}
```
[Try it online!](https://tio.run/##hZFfC4IwFMWf7VNUEGxrA28GPYwRe@s72B7ENOb8E9OnrM9uUxQMIt/O7@zcuzMWs3scd11GDbU8RZLWWJcNIUTyNq0sssKnmah5xhjHvWEcmB7sSxAZZio0ijlhlNOv0QhB7UfLSS7FxvJ3V0S6RLhdeeMNoojyvIpRrZ9JlaLBxeSA@cqToa8Wjn8nvgN9BmYISvgTwtI4DOPBDN3IcUD4Xw6WysFULpihW8qm9QvtYGp3muH4uId10RRtL4ktdKOj8rze3a7llva/e8Buwbv7AA "C (gcc) ‚Äì Try It Online")
[Answer]
# [Actually](https://github.com/Mego/Seriously), 13 bytes
```
‚î¨‚å†‚å†√á√°‚ï´k‚å°M‚å°M√ü=
```
[Try it online!](https://tio.run/##S0wuKU3Myan8///RlDWPehYA0eH2wwsfTV2d/ahnoS8IH55v@/9/dHS0kY5BrA6QNASSJkA2kALydEFcY7CUAVAKJGgC5YGlDEEqYwE "Actually ‚Äì Try It Online")
## How it works?
This submission **actually** makes use of complex numbers. If taking input as a matrix of complex entries was allowed, then it would be [8 bytes](https://chat.stackexchange.com/transcript/message/43075355#43075355).
```
‚î¨‚å†‚å†√á√°‚ï´k‚å°M‚å°M√ü=  ‚Äì> Full program.
‚î¨              ‚Äì> Transpose.
 ‚å†       ‚å°M    ‚Äì> For each list in the input's transpose do the following:
  ‚å†    ‚å°M         ‚Äì> For each two-element list of the form [a, b]...
   √á              ‚Äì> Turn it into a complex number (a+bi).
    √°             ‚Äì> Find its complex conjugate: Push (a-bi).
     ‚ï´k           ‚Äì> Push [Re(N), Im(N)], so [a, -b].
           √ü=  ‚Äì> Check whether the result equals the input.
```
[Answer]
# Pyth, 9 bytes
```
qCmm,hk_e
```
Explanation:
```
qCmm,hk_ekdQQ  Autofill variables
    ,hk_ek     [a,-b]...
  mm      dQ    ...for each [a,b] in the input (m...Q)'s rows (m...d).
 C             Transpose.
q           Q  Is this result equal to the original?
```
[Test suite](http://pyth.herokuapp.com/?code=qCmm%2Chk_e&input=%5B%5B%5B2%2C0%5D%2C%5B2%2C1%5D%2C%5B4%2C0%5D%5D%2C%5B%5B2%2C-1%5D%2C%5B3%2C0%5D%2C%5B0%2C1%5D%5D%2C%5B%5B4%2C0%5D%2C%5B0%2C-1%5D%2C%5B1%2C0%5D%5D%5D&test_suite=1&test_suite_input=%5B%5B%5B2%2C0%5D%2C%5B2%2C1%5D%2C%5B4%2C0%5D%5D%2C%5B%5B2%2C-1%5D%2C%5B3%2C0%5D%2C%5B0%2C1%5D%5D%2C%5B%5B4%2C0%5D%2C%5B0%2C-1%5D%2C%5B1%2C0%5D%5D%5D%0A%5B%5B%5B1%2C0%5D%2C%5B2%2C0%5D%5D%2C%5B%5B2%2C0%5D%2C%5B1%2C0%5D%5D%5D%0A%5B%5B%5B1%2C0%5D%2C%5B2%2C-3%5D%5D%2C%5B%5B2%2C3%5D%2C%5B1%2C0%5D%5D%5D%0A%5B%5B%5B42%2C0%5D%5D%5D%0A%5B%5B%5B2%2C0%5D%2C%5B2%2C1%5D%2C%5B4%2C0%5D%5D%2C%5B%5B2%2C-1%5D%2C%5B3%2C0%5D%2C%5B0%2C1%5D%5D%2C%5B%5B4%2C0%5D%2C%5B0%2C-1%5D%2C%5B1%2C-1%5D%5D%5D%0A%5B%5B%5B0%2C1%5D%2C%5B0%2C2%5D%5D%2C%5B%5B0%2C2%5D%2C%5B0%2C1%5D%5D%5D%0A%5B%5B%5B1%2C0%5D%2C%5B2%2C3%5D%5D%2C%5B%5B2%2C3%5D%2C%5B1%2C0%5D%5D%5D%0A%5B%5B%5B3%2C2%5D%5D%5D&debug=0).
[Answer]
# C, ~~¬†111¬†~~ ~~¬†110¬†~~ 108 bytes
*Thanks to @Jonathan Frech for saving a byte and thanks to @ceilingcat for saving two bytes!*
```
i,j,r;f(A,n)int*A;{for(r=i=0;i<n*2;i+=2)for(j=n*2;j;r|=A[i*n+j]-A[j*n+i]|A[i*n-~j]+A[j*n-~i])j-=2;return!r;}
```
[Try it online!](https://tio.run/##jZDLaoQwGEb3PkU6UDD6B3JxLpBm4XPYLIodSwJNS2pXjvPqNsahnaI4E8jtg@@EnJq81fUwGLDgZZOW4LBxbVbKrvnwqVdGUWmeXMalyRXHY2jVeLXSn1RZmczlVpOysuFg9Ckm5Gx1HiNyNhpborj0x/bbuwcv@yE8gN5fjEtx0iUojDFoj18tqzRSqONAgQODIu6EgQgHegnoGDCgvYzVTx/KTbp5fH12G0BNGjmABMYy@QfnE5xF6DRvYDggPsOIawwRYRG3OGKJU0ycgq93C0Bs1t3e74mwNfp2SdRuokc9f6rWMLulD@6vRd3lab@EOUyYAJhVf4uHi6R@@AE)
# [C (gcc)](https://gcc.gnu.org), ~~¬†106¬†~~ 104 bytes
```
i,j,r;f(A,n)int*A;{for(r=i=0;i<n*2;i+=2)for(j=n*2;j;r|=A[i*n+j]-A[j*n+i]|A[i*n-~j]+A[j*n-~i])j-=2;A=!r;}
```
[Try it online!](https://tio.run/##jdDdaoMwHAXwe58iKwwS/QdMYj8gzUWew3kx3BwJLBupd9a@uouxbB2KraDGA@cHnpp@1PUwGLDgZYM1OGJcm2rZNV8ee2VULs3RpVyaTHEyhlaNn1b6s9KlSV1mK6pLGw6mOseEXmyVxYheTEUsVVxq9eRlPwQcfb4ah0nSJShcY9C@n1pWVkihjkMOHBgU8U0ZiHDIr0E@BgzyXsbqtw/lBm@e317cBlCDowNIECKTfzifcBbR6b7DcEB8xohbhorwEPccseQUk1Pw9W4BiM2628d3omxN3y4NtZv0OM/fVGvMbukH97dDPbTTfok5TEwAZtXf4uE6Uj/8AA)
[Answer]
# [Actually](https://github.com/Mego/Seriously), 13 bytes
```
;‚î¨‚å†‚å†d¬±@q‚å°M‚å°M=
```
[Try it online!](https://tio.run/##S0wuKU3Myan8/9/60ZQ1j3oWAFHKoY0OhY96FvqCsO3//9HRCtFGOgoGsQo6YIYhmGECFokFskCCuhBBY5gyA7AyiKwJQhCqzBCiNxYA "Actually ‚Äì Try It Online")
Explanation:
```
;‚î¨‚å†‚å†d¬±@q‚å°M‚å°M=
;              make a copy
 ‚î¨             transpose copy
  ‚å†‚å†d¬±@q‚å°M‚å°M   for each row:
   ‚å†d¬±@q‚å°M       for each cell in row:
    d              remove last element from list
     ¬±             swap sign
      @q           insert at end of list
            =  compare equality with original
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 9 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
√º‚ô¶‚ïßŒì‚ô•‚îúe√Ø‚àû
```
[Run and debug it](https://staxlang.xyz/#p=8104cfe203c3658bec&i=%5B%5B%5B2,0%5D,%5B2,1%5D,%5B4,0%5D%5D,%5B%5B2,-1%5D,%5B3,0%5D,%5B0,1%5D%5D,%5B%5B4,0%5D,%5B0,-1%5D,%5B1,0%5D%5D%5D%0A%0A%5B%5B%5B1,0%5D,%5B2,0%5D%5D,%5B%5B2,0%5D,%5B1,0%5D%5D%5D%0A%0A%5B%5B%5B1,0%5D,%5B2,-3%5D%5D,%5B%5B2,3%5D,%5B1,0%5D%5D%5D%0A%0A%5B%5B%5B42,0%5D%5D%5D%0A%0A%5B%5B%5B2,0%5D,%5B2,1%5D,%5B4,0%5D%5D,%5B%5B2,-1%5D,%5B3,0%5D,%5B0,1%5D%5D,%5B%5B4,0%5D,%5B0,-1%5D,%5B1,-1%5D%5D%5D%0A%0A%5B%5B%5B0,1%5D,%5B0,2%5D%5D,%5B%5B0,2%5D,%5B0,1%5D%5D%5D%0A%0A%5B%5B%5B1,0%5D,%5B2,3%5D%5D,%5B%5B2,3%5D,%5B1,0%5D%5D%5D%0A%0A%5B%5B%5B3,2%5D%5D%5D&m=1)
]