[Question]
  [
## Defintion
A [centrosymmetric matrix](https://en.wikipedia.org/wiki/Centrosymmetric_matrix) is a square [matrix](https://en.wikipedia.org/wiki/Matrix_(mathematics)) that is symmetric about its center. More rigorously, a matrix \$A\$ of size \$n \times n\$ is centrosymmetric if, for any \$i,\: j \in ([1, n] \cap \mathbb{Z})\$ the following relation is satisfied:
$$A\_{i,\:j}=A\_{n+1-i,\:n+1-j}$$
## Examples of such matrices
Here is an illustration of the symmetry of a matrices like these (borrowed from the aforementioned Wikipedia article):
[![Centrosymmetric 5 by 5 matrix illustrated in a really nice way](https://i.stack.imgur.com/a3ZBh.png)](https://i.stack.imgur.com/a3ZBh.png)
An even-side-length (\$4\times 4\$) centrosymmetric matrix:
$$\left(\begin{matrix}
1 & 2 & 3 & 4 \\
5 & 6 & 7 & 8 \\
8 & 7 & 6 & 5 \\
4 & 3 & 2 & 1\end{matrix}\right)$$
And an odd-side-length (\$3\times 3\$) one:
$$\left(\begin{matrix}
1 & 2 & 3 \\
5 & 6 & 5 \\
3 & 2 & 1\end{matrix}\right)$$
## Task and Specs
Given a square matrix of size at least \$2\$, output one of two distinct and consistent values, deciding whether the matrix is centrosymmetric or not. You can assume that the matrix will consist entirely of positive integers.
**However, your code must also be centrosymmetric.** That is, it must be a program / function (or equivalents) consisting of \$n\$ lines, each of which containing \$n\$ **bytes** in your language's encoding, and must satisfy the definition given above, but with bytes instead of positive integers. Your submission's score will be the value of \$n\$, with a lower \$n\$ being better. 
You can take input and provide output through any [standard method](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods) and in any reasonable format, while taking note that [these loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are forbidden by default. You may (optionally) choose to take the size, \$n\$, as input too (unless you take input as a 1D list, in which case you may only take \$n^2\$ as additional input).
## Test cases
Truthy:
```
[[1, 2], [2, 1]]
[[1, 2, 3], [5, 6, 5], [3, 2, 1]]
[[10, 5, 30], [2, 6, 2], [30, 5, 10]]
[[100, 100, 100], [100, 50, 100], [100, 100, 100]]
[[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]]
[[3, 4, 5, 6, 7], [5, 6, 7, 8, 9], [3, 2, 10, 2, 3], [9, 8, 7, 6, 5], [7, 6, 5, 4, 3]]
```
Falsy:
```
[[1, 2], [1, 2]]
[[1, 2, 10], [5, 6, 5], [11, 2, 1]]
[[14, 5, 32], [2, 6, 2], [30, 5, 16]]
[[19, 19, 19], [40, 50, 4], [19, 19, 19]]
[[1, 2, 20, 4], [7, 6, 7, 8], [8, 7, 6, 6], [3, 3, 2, 1]]
[[3, 4, 5, 6, 7], [5, 6, 7, 8, 9], [4, 5, 10, 4, 5], [5, 6, 7, 8, 9], [3, 4, 5, 6, 7]]
```
  
[Answer]
# JavaScript (ES6), size ~~12~~ ~~11~~ 9
All versions return **false** for centrosymmetric or **true** for non-centrosymmetric.
---
## 1-dimensional array + length, size 9 (89 bytes)
Takes input in currying syntax `(length)(array)`, where *array* is 1-dimensional.
```
w=>a=> //
a.some //
(v=>v- //
a[--w])//
/////////
//)]w--[a
// -v>=v(
// emos.a
// >=a>=w
```
[Try it online!](https://tio.run/##rZNba4MwFMff/RSHvmhotN7bDhRG3/cFOh8ks1tHNUWdsk/vcky8rPTCYILxf@4m/vxMm7Ri5fFcmwV/y7pD1LVRnEYxrFZaalU8z1AZTRQ3Zu/bm2abEKFWwyUUSVrT3KdCgdnEUWOgynJeWb0vjtI4ajvGi4qfMuvE3w19lxV1yavvPM/q8siedKLN4wfDJ8ZeA3AouFQ8XQqOlpDLrO0sCzxMDCiEVKxCevRRmY2Z4NmYjbmiUo7zZMSx7xXbdFoGBwQXjmG50sgJf789@NMG1hQ2aG16OezIp3c25QayXd9o6jO2lD1hOzsaezq3bR@cD5MSi3HslYEbRwy0LEvkLkZsFrBEe4RH2SNCQ3wASdkjTqOtoBpthdZkS8AmW2K20BIrT88Gi2JmsY@03Amwn2uDEAJL0MGo@FfJMmDCTQR1v/akvxYvvDDZH@HE521Q1Pd1JGXBcKpY5zwk1JeEujcJDe8Ui2@qbmQHC5DQnrIp9hBM11ZkrmcYjWiiK1RIeRT@A05f/XtUqlsAz/rgwO4H "JavaScript (Node.js) – Try It Online")
---
## Matrix + width, size 11 (131 bytes)
Takes input in currying syntax `(width)(matrix)`.
```
/**/w=>a=>a
.some(r=>r.
some(v=>v-a
[y][w-++x],
x=!y--),y=w
);'*/'/*';)
w=y,)--y!=x
,]x++-w[]y[
a-v>=v(emos
.r>=r(emos.
a>=a>=w/**/
```
[Try it online!](https://tio.run/##pZPZUoMwFIbv8xSxN5CSpCxdXCbMON77AsgFE6nWEeKECuXpaxZqY5U6jkyAkz9nyfLlpWiLhsvN25bU4rHcr9l@Np3OOpYWqgHaiKr0JUslBcZsWdqSAmR9nnUkCHY5Bjt20ROCcM86gG686cybTb0bBDrWY0RIf8F2AOe7ICBdlvcZKEibstYvK9EAKlMmjUlBkTLVOl1@z0XdiNeSvoon37sr660UTV9V5VZu@LWHgDu@9mPkZ1mEYZxjmMUYRnmOTn2Sgw@GiXZbYLjEcKHNxKjjQaHyU1HhkH05FEqsHoXjgaEeth8dYezFSf/T4XuWuTNnDOfHaa8wvNS9S2Me1jE3biNLWehcOouZtM7xNR2GV85ehMeNujKDTpnBNKmSHypFkSoFIJw4IE2wFhyarOAgZQWHKys4cFnBIcwKDmZWcFizggPcMI8jdYPHEb0JyGlVvPkNSzNKaWN7nKWc8udC3qlLcrv1kXpgAD3oN@Jd8hJypSMF5pe98B7qe1ET/id@zf8sv1F4AnAU/UKwPfQkHiF4ORqoDt@@hq@BXgOiM3QW3PgQsPqZ3OVA3b/JnQ@30TqOwe0kUZX2Hw "JavaScript (Node.js) – Try It Online")
### Payload
```
w => a => a.some(r => r.some(v => v - a[y][w - ++x], x = !y--), y = w)
```
### Container
```
/**/CODE;'*/'/*';EDOC/**/
```
---
## Matrix only, size 12 (155 bytes)
This is my original solution, which computes the width of the matrix by itself.
```
/**/a=>a[w=a
.length-1,s=
'some']((r,y
)=>r[s]((v,x
)=>v-a[w-y][
w-x]))////*/
/*////))]x-w
[]y-w[a-v>=)
x,v((]s[r>=)
y,r((]'emos'
=s,1-htgnel.
a=w[a>=a/**/
```
[Try it online!](https://tio.run/##pZPdbtsgGIbPuQqUE@wMHDtO0nYSlqae7wYYB4jRpFNsKvCc@OozftyURXE1aUjYfC/fH@jhlxiEleb1rSed/qkuL/SyWi5XgjaCnagAxVF1@/5AKmwpQFa3CvEsM3gEOW0Ms84Y8NkbA3ERZOQMnMiZ5/nKjeUKuOlGnvMzOQHGR3JiggwNzcEZD1nGLTPeGLFxBlKttghQiyty6PedOhZAUBfRUOHbukjdWX1UxVHvM/Ssut5oO7at6s2r/IpykO6/ZIxVGK45hmyNYcVdU3cdMKy9zxbDHYZbv6yDOhNROicXUk55d1OJOupVORNV@r348e5hvb2xrw6ftIrh5qPbBwwfvfUYlu/tb4Lb7Al8itCrT/B3LgyfkvOXH5fzFDaTGtMypKpDmds6AMJFytICeyUFKiopVVFJ0boqV76ikkIWlZS0qKS4RSVlLiopeFFJ6YtKiuAC8KIVb5mlDSuKwkZL0kYW8iDMs3tE3/osdwN@gQhmVv82UkHp9BzdXBL60X3XHZH/znH4z8NRlTcgV9VnJEcK6vUMybv7UQ6FOANqE8WByWRrvsf1u/fDfYJ3E4D/R/BmeozRcQ7yJIkrc/kD "JavaScript (Node.js) – Try It Online")
### How?
We need a few critical tokens that cannot be split:
* `some`
* `length`
* `)=>`
Line-feeds may be inserted almost anywhere else.
The unrolled payload code reads as:
```
a => a[w = a.length - 1, s = 'some']((r, y) => r[s]((v, x) => v - a[w - y][w - x]))
```
and is wrapped inside the following structure:
```
/**/CODE////*/
```
which, once reversed, becomes a valid block comment:
```
/*////EDOC/**/
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), score 2
```
⁼Ṛ
Ṛ⁼
```
[Try it online!](https://tio.run/##y0rNyan8//9R456HO2dxATGQ9f///2hjHQUTHQVTHQUzHQVzJIaFjoKljgJQ1khHwdAATBmDhSzA0mZgpXAG0AjjWAA "Jelly – Try It Online")
Takes input as a flattened square matrix (vector of size \$n^2\$).
[Answer]
# [Befunge-93](https://github.com/catseye/Befunge-93), size 24
```
   &:00p110p920p::*:v   
vp01:+1g01-1pg02g01&_v#<
>00g`#v_>:           1$^
v2p011<  v:g00p029p01< @
>0g1+20p^>*:#v_1# .#<@ .
v+1g00gg02g01<$ >1+10pv0
>:10g-\88++20g -g-     |
vg02p011_v#`g00g01-1  <1
>1+20p   >:   ^ ^      <
                        
                        
                        
                        
                        
                        
<      ^ ^   :>   p02+1>
1<  1-10g00g`#v_110p20gv
|     -g- g02++88\-g01:>
0vp01+1> $<10g20gg00g1+v
. @<#. #1_v#:*>^p02+1g0>
@ <10p920p00g:v  <110p2v
^$1           :>_v#`g00>
<#v_&10g20gp1-10g1+:10pv
   v:*::p029p011p00:&   
```
[Try it online!](https://tio.run/##xVLLboQwDLz7KyyBOBCBbPZRsKKID1mxq0rb3CouzWn/nU4CUnvpuUYyxPHY4zHvz4@vz/jcNmZuTGRVlXUaZDVrLSFIaRU1p1G00zXKgI/mnipPQSQ@qnQPxj@m9UJpAEQ9c7KIijJMOHuegYjqUHsJrQGoFfeVn7mnlOtL3Kv7moM60EhCwVRidxtHB1zkLnaly4sScnMXMHlkaGbH7JVC6YCcQmvBU8wT/2H/e@H3987TAhz0choo64eZJB4q571AgkSvAshKQALnxvHWYXoLJHlTgHLtARuynFnvRD3Pvuq5ymJZG5bSIUqgGYLt20Zm3rYvXRIttf4iaeFQOZAHk2avvhZ26ixvKg@Y8MfYsW1FRWsQ3LYLn/jMF77y2@FHnhAbWAXuhMOI4BWXuz/z6Rs "Befunge-93 – Try It Online")
**Input:** `n`, followed by the elements of the array, all separated by spaces. NOTE: you may need to use a different interpreter if you have a large enough input.
I'm sure there's a better way to do this, I just wanted to try this in Befunge. The actual code portion is the top half.
## How?
The code is divided into two main sections, the **initialization** and the **verification**.
**Initialization:**
```
   &:00p110p920p::*:v   
vp01:+1g01-1pg02g01&_v#<
>00g`#v_>:           1$^
```
This section of the code writes the input matrix right below the code as ASCII characters. Both this and the next section use the three cells at the top left of the code as data. They are stored as `n, i, j`.
**Verification:**
```
                     v 
                     1
v2p011<  v:g00p029p01< @
>0g1+20p^>*:#v_1# .#<@ .
v+1g00gg02g01<$ >1+10pv0
>:10g-\88++20g -g-     |
vg02p011_v#`g00g01-1  <1
>1+20p   >:   ^ ^      <
```
This sections checks every index \$i, j\$ [1-indexed] against the condition \$ A\_{i, j} = A\_{n+1-i, n+1-j} \$. However, we have a problem: we have \$j\$ offset by \$8\$. To fix that, the following formulae are used:
\$ i' = (n + 1) - i \$
\$ j' = n + 1 - (j - 8) + 8 = (n + 1) + (8 + 8) - j\$
The other portions of code are unread garbage to make it centrosymmetric.
[Answer]
# [Haskell](https://www.haskell.org/), \$n = 8\$
*No comments!*
Takes input as a 1-D list
```
s a b=  
    a/=b
f =s<*> 
 reverse
esrever 
 >*<s= f
b=/a     
  =b a s
```
[Try it online!](https://tio.run/##JYzBCsIwEETv@Yo9eGhLsKR6zObUq18gHjaYYLBtSjb4@3GrMww8BmZexO@wLC2tey4VZqp0vuUtpyd0nXV93xgIPAIoENGIXkVAtoOTpoRPKBxU4B9J4wbLCFF5HOkYHDP0csFtpbThXtJWTxHuRk/6oo3kKv7TpM2jfQE "Haskell – Try It Online")
# \$n= 10\$
Takes input as a 2-D matrix
```
r =reverse
s a b=a/=b
f   =s<*>r
c  =concat
g =  f<$>c
c>$<f  = g
tacnoc=  c
r>*<s=   f
b=/a=b a s
esrever= r
```
[Try it online!](https://tio.run/##HY2xDoMwEEP3@4obGABFRUDHXKau/QLEcKSBokKCkqi/n54qL0@2Zb85fdxxlP28Qsz44My3Z/Bhf2Fda9M0JSJF93UxOUjIuBB3tMCKiJR0ayJYIRu85QwbEuKqK2PBmkpLiXCDzNYHK4mFaFqdhHCFhTqmRRYTuPR/IIzl5N3TFXefqw2nqVeDGlU/q2lUd9Eo1IsziDeXHw "Haskell – Try It Online")
Thanks to [potato44](https://codegolf.stackexchange.com/users/69655/potato44) for all their help in chat. And [Lynn](https://codegolf.stackexchange.com/users/3852/lynn) for golfing off a row.
## Explanation
The general idea here is a simple one, we `concat` the list and compare it to it's reverse. However since we want to be centrosymmetric we have to tread carefully. First we write the code as we would normally:
```
g=((==)<*>reverse).concat
```
Now in order for our reverse lines to also be valid Haskell we need the left hand side of our equations to look like a function definition `tacnoc.)esrever>*<)==((` doesn't.
The first step to fixing this is disposing of parentheses.
```
s a b=a==b
f=s<*>reverse
g=f.concat
```
However we have some new problems now. Both `.` and `==` when reversed are the same, so our reversed lines attempt to redefine the operators (`<*>` reversed is `>*<` so we are fine on that front). `.` can be replaced with `<$>` since functions are functors. And we can replace `==` with `/=`, which negates our output, but that is still within the specs. Now we have
```
s a b=a/=b
f=s<*>reverse
g=f<$>concat
```
In order to trim down our line length we alias `concat` and `reverse`.
```
r=reverse
s a b=a/=b
f=s<*>r
c=concat
g=f<$>c
```
Now we just finish this by making everything centrosymmetric and square.
The shorter 1-D version works in much the same way except since there is no need to `concat` we can save two lines by removing it.
[Answer]
# [Python 2](https://docs.python.org/2/), size 10 (109 bytes)
```
def f(a):#
 return(a#
==[r[::-1#
]for r in#
a[::-1]])#
#)]]1-::[a
#ni r rof]
#1-::[r[==
#a(nruter 
#:)a(f fed
```
[Try it online!](https://tio.run/##vVO7boMwFJ3rr7jCAyA5FYaEJJboUqlf0M31YCmgIEUmcsiQryd@0ThRU6lLB@D6nHNfx@J4GfeDKqdp13bQZTJnGIFux7NWmcSoabjmjC0oRqIbNGjoFUbSQULkGOFcCLpgjEuEVW94PXQCYQdp3jQIy0zp89hqQJjlMjNd2t101L0aIfk0zP6SIFtamtLAOacESkGAlwRMCxM4hEBl4xWBmsDKhpVDZ0lhUKMpQmYdilQep8UsK@zBvyzi4tXD@VsQdyewvA2wJrCxp40L54mWTnYbyua49jbjPpnANtqhuC24dWRUNISuVCWEYOjFmydJ2rylxN4ZQg4KH0g@5OHUPrHVfaPFaPHgK6V3xvoNqvKJsXWQmbn944wIpjrHIipqW870@mdD62DPHw1dhuv2wmeeR0V@N9QT6fuwa9OZTZLkX/8V0@/1dDz0Y5Z@qTTPpys "Python 2 – Try It Online")
### Previous [Python 2](https://docs.python.org/2/), size 14 (209 bytes)
```
lambda a:all(#
a[i][j]==a[-i#
-1][-j-1]for #
i in range(  #
len(a))for j #
in range(len(#
a)))         #
#         )))a
#(nel(egnar ni
# j rof))a(nel
#  (egnar ni i
# rof]1-j-[]1-
#i-[a==]j[]i[a
#(lla:a adbmal
```
[Try it online!](https://tio.run/##3VPLboMwEDzXX7GCAyCZikdCHhK9VOoX9Ob44CiQGDkmIvSQr6deAwmJmkq9Fgmznpld747F6dIeap10Zb7plDhudwLEWijlu0QwyVnF81ywULokjDkLK7OWdQMukSA1NELvCx/MVhXaF0GAXIXsyCFuSgVBAOPjEvcaG1wQ19eF8ou9Fg1oadgKmro0DOIovnKArOF4bDphZiWuDJnIc14xLhmWUsr0D2K3PQrVnRqpW3A@m6/2cHEIdiewb8ZYTCHhFFhCIeYYWIRCivGcQkZhjmFq0VESGdRooiEzG4qkPR5HoyzCTb8gYuP5w/4qmJ5OYXZrYEFhibulDceOZlZ2awpz7PGYcZ9MYTWZIboNuLLkpOgQ2lIp53xNXnrzBPXyN4@W5nYJsdDwAedDqHPxxFb7nQwWRw@@xvGdsf0EafLE2GyQmb771xoxmGodm1CTY5ORXvxsaDbY80dDZ8N198Jnnk@K/G5oT3jv9a7wRtZxnH/3P5qZXs8nJVvf22gvCLpv "Python 2 – Try It Online")
[Answer]
# Pyth, size 6 (41 bytes)
```
q_M_QQ
q.q   
   q.q
QQ_M_q
```
[Try it here](http://pyth.herokuapp.com/?code=q_M_QQ%0Aq.q%20%20%20%0A%20%20%20%20%20%20%0A%20%20%20%20%20%20%0A%20%20%20q.q%0AQQ_M_q&input=%5B%5B1%2C%202%2C%203%2C%204%5D%2C%20%5B5%2C%206%2C%207%2C%208%5D%2C%20%5B8%2C%207%2C%206%2C%205%5D%2C%20%5B4%2C%203%2C%202%2C%201%5D%5D&debug=0)
### Explanation
The first line reverses the input and each row, and checks if we're left with a copy of the input.  
The `.q` in the second line exits the program, so everything after that, as well as the `q` before it, is a no-op. 
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), score ~~7~~ ~~6~~ ~~5~~ 4
Full program. Prompts for matrix expression from stdin. Prints a 1 or a 0 and then throws a consistent error. No comments!
```
r←,⎕
r≡⌽r
r⌽≡r
⎕,←r
```
[Try it online!](https://tio.run/##pVJLTsMwEN3nFLMzSEZykjZt2SEQCyQ@gu6qLqzUbSKFJrKDql6ggFQQLFiy4CC9TC4SxnZKQ0XTBZESj2fmvfm88Cw5Gs15kk7K4vWjf3tyUyzeGJBTAqRYvKPv7JJA8fIJIc/DCHiSgJAylQr4dASjWGUJn@PJJ9NU5XEI90IpPhFwkOaRkLNYCZgJgrCIJznwcS4kYATGsVS55Tp0iqfHrJRYmmJFRxbPX8VyJdFYrtCWDnopRmWJiSXpy4c8mh8TB8yTObbTi7vrKzIYuBS8IYWBR8EdDhuSKPg6r00hoNDWpm@8DSiGiQhjFX9QlfKt32UNSKbj9qMhxm5v3X8S9rRNobXpvEOhq29dY65HaZm0xmk0jelbk/zmo9Cr7YNtltUzwVqdyjRUvi5Fznmi9opjzuYpXbaljuvuk8eO43s75Al2I3Eu@5rdVdKYJddCzf16a0Tnb1mCaqP/l6VV/W02cZdyNRIs9Q0 "APL (Dyalog Unicode) – Try It Online")
`⎕` prompt for expression and evaluate it  
`,` ravel (flatten) it  
`r←` store the result in `r` (for **r**avelled)
`⌽r` mirror `r`  
`r≡` implicitly print whether `r` is identical to that
`≡` depth of `r` (gives 1)  
`r⌽` use `r` to rotate that  
(this will always cause a `RANK ERROR` and quit because a matrix is not permitted as left argument to `⌽`)
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), size ~~9 8~~ 7
```
{.flat#
#}talf.
#  ],R[
eq # qe
[R,]  #
.flat}#
#talf.{
```
[Try it online!](https://tio.run/##nZLLbsIwEEX3/oorIkFSWVbeQFDZVOoHoO4oi0jYLVKAkKSLCPHt1HacYqAs2kXi8cyd10lKXhXpedtiKPCM85GJIm8c4pyavBCMOMCKLpaEH@DgwMlyQVeAQ7TsJHVadjzXeYvRW/XVfLbZaEbEvoLrBhShR@GGFIHnUdJ5KCLlTChSikSZkfb2El96pcY3makpEnX@wO9lvrp0LxXXdnJz/xHY3SniywBjiom6TbTZTxRr2WUolaPbq4zrZIqptYN/WXCqg1ZRY@pSkefhSAA2FEyyIydCFMLB@@41L2reZoNbiPq01gj8G4pBcIWxmzcKH2BMjUxO2T16bYNQ87FCVtuwD49/x5caGH/EF5uP2wkfEbaK3OErq82uUQBf9muOTVPzQmSQGIlwi82O1/M521frmm3z0n1iPP/gldcfssbsv//@Nw "Perl 6 – Try It Online")
~~`reverse` is the bottleneck here. I've changed it to the technically longer, but much more splittable `[*-1 X-^*]`.~~ Okay, I've changed it to `[R,]` after seeing [Brad Gilbert's answer](https://codegolf.stackexchange.com/a/169008/76162) to another question.
The flattened code is `{.flat eq [R,] .flat}`.
Edit: Damn, I've realised I don't even *need* to flatten the first list, but attempts at shortening it to a size 6 have failed with just *one* byte too many to fit...
```
{@_#}_@
eq#<<|
[R,] #
# ],R[
|<<#qe
@_}#_@{
```
:(
Though if we take it as a one dimensional array, it's easy to fit it in a size 6.
```
{$_# }
eq #_$
[R,] #
# ],R[
$_# qe
} #_${
```
[Try it online!](https://tio.run/##lZPZaoNAFIbv5ylOojRaBnGJJlGSm0IfIPQuDUHI2ApGzWgLEnx26yzWSWhKe6Ge5T/LfIMloVnQnRp4SGAN3UU/aNAicgbtoKPdFu9BQxrs8XaHWOpMUMtSl66KG5i90I/6vQlnEUoKCobhYHBNDIaLwTFNjEQEg8eCPoYAg89Mj0cHid1He40tKwPZxBNxxx5kNnPEi@W57d/43wJ1Oob5uMACw5J5S24OG825bFyK1fDxrOK6GMNKOYM9HnDFk0pTafJWnmnCBQEkhpVkcW2R@I1Q0@oxohYhRnP6mj/HWUWacHrLk3@VEzn2DVDHuSIqVvfcO0QDKesXFg8nIGlyVEpKGesO6cXPJAPJ5Z8k5/KehfAebKXJbyRLmuY1Y/lUHAmkdUWyJISeKEoMfbLO0pxUm41V0GNlneLSeBzqxzaRuA99wvtHqmNR8kloRaK//ylf "Perl 6 – Try It Online")
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/) (REPL only), size 8 (71 bytes)
```
f=#[[c=-
1;;1;;-1
,c]]==#&
(*      
      *(
&#==]]c,
1-;;1;;1
-=c[[#=f
```
Returns `True` for centrosymmetric input, and `False` otherwise.
On Mathematica REPL, lines with syntax errors are ignored (with a thick red bar appearing on the side of the screen). Here, only the first three lines, `f=#[[c=-1;;1;;-1,c]]==#&`, are executed.
This code captures the function in the name `f`.
Sadly, the built-in `PalindromeQ` is too long. 
[Answer]
# [Pyt](https://github.com/mudkip201/pyt), size 1
```
₽
```
[Try it online!](https://tio.run/##K6gs@f//UdPe//@jjXUUTHQUTHUUzHQUzJEYFjoKljoKQFkjHQVDAzBlDBayAEubgZXCGUAjjGMB "Pyt – Try It Online")
Checks if the input (in the form of concatenated rows) is a palindrome.
[Answer]
# [Japt](https://github.com/ETHproductions/japt), size ~~9~~ 4 (11 bytes)
```
UªSê
êSªU
```
[Try it online!](https://tio.run/##y0osKPn/P/TQquDDq7i4uA6vCj60KvT//2hDSx0IMjHQMTUAkTCRWAA "Japt – Try It Online")
Takes one-dimensional input, checks if it is a palindrome. If you want, you can fill the two empty lines for some ascii art.  
The old two-dimensional version, rotates the input twice and checks if it's equal to the original:
```
W=U  I
Wz2;II
Vc)eUc
cUe)cV
II;2zW
I  U=W
```
[Try it online!](https://tio.run/##y0osKPn/P9w2VEHBkyu8ysja05MrLFkzNTSZKzk0VTM5jMvT09qoKpzLU0Eh1Db8///oaENLHQUIjtVRiDYx0FEwBWITEAdJKhYA)
[Answer]
# [Husk](https://github.com/barbuz/Husk), size 3
```
Ṡ=↔
=↔=
↔=Ṡ
```
[Try it online!](https://tio.run/##yygtzv7//@HOBbaP2qZwgQhbLhABFPn//78SVAKOgXwlAA "Husk – Try It Online") Input as 1D-List. Each line defines a function, but only the one on the first line is called. 
`Ṡ=↔` is a palindrome tests which checks whether the input equals (`=`) its reverse (`↔`).
---
## [Husk](https://github.com/barbuz/Husk), size 4
```
Ṡ=↔Σ
Σ↔=Ṡ
Ṡ=↔Σ
Σ↔=Ṡ
```
[Try it online!](https://tio.run/##yygtzv7//@HOBbaP2qacW8x1bjGQtgXyubCI/f//P1oJLq6kowSXAbKxi8cCAA "Husk – Try It Online") For input as 2D-matrix, we concatenate (`Σ`) the list of lists before checking that it is a palindrome.
[Answer]
# [MATL](https://github.com/lmendo/MATL), score 4
```
t,!P
]=%?
?%=]
P!,t
```
Input has the format `[1 2; 2 1]`, using `;` as row separator.
Output is via STDERR ([allowed](https://codegolf.meta.stackexchange.com/a/2451/36398) by default):
* For centrosymmetric input a consistent error error is produced. With the current Linux and Octave versions in TIO the following STDERR output is produced (disregarding the final lines that start with `Real time: ...`):
```
octave: X11 DISPLAY environment variable not set
octave: disabling GUI features
Python 2.7.15 (default, May 16 2018, 17:50:09) 
[GCC 8.1.1 20180502 (Red Hat 8.1.1-1)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> >>> /usr/include/c++/8/bits/basic_string.h:1048: std::__cxx11::basic_string<_CharT, _Traits, _Alloc>::reference std::__cxx11::basic_string<_CharT, _Traits, _Alloc>::operator[](std::__cxx11::basic_string<_CharT, _Traits, _Alloc>::size_type) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>; std::__cxx11::basic_string<_CharT, _Traits, _Alloc>::reference = char&; std::__cxx11::basic_string<_CharT, _Traits, _Alloc>::size_type = long unsigned int]: Assertion '__pos <= size()' failed.
panic: Aborted -- stopping myself...
```
The error may be different depending on the Linux and Octave versions, but will be consistent across inputs.
* For non-centrosymmetric input no error is produced, and the STDERR output on TIO is
```
octave: X11 DISPLAY environment variable not set
octave: disabling GUI features
Python 2.7.15 (default, May 16 2018, 17:50:09) 
[GCC 8.1.1 20180502 (Red Hat 8.1.1-1)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> >>> 
```
[Try it online!](https://tio.run/##y00syfn/v0RHMYAr1lbVnste1TaWK0BRp@T//2hDBSNrBSMFw1gA) Or verify all test cases:
* Centrosymmetric: [1](https://tio.run/##y00syfn/v0RHMYAr1lbVnste1TaWK0BRp@T//2hDBSNrBSMFw1gA), [2](https://tio.run/##y00syfn/v0RHMYAr1lbVnste1TaWK0BRp@T//2hDHQUjHQVjawVTHQUzHQVTawVjsIhhLAA), [3](https://tio.run/##y00syfn/v0RHMYAr1lbVnste1TaWK0BRp@T//2hDAx0FUx0FYwNrBSMdBTMdBSNrIAcsZmgQCwA), [4](https://tio.run/##y00syfn/v0RHMYAr1lbVnste1TaWK0BRp@T//2hDAwMdBRhhDWGZovBgRCwA), [5](https://tio.run/##y00syfn/v0RHMYAr1lbVnste1TaWK0BRp@T//2hDHQUjHQVjHQUTawVTHQUzHQVzHQULawULMAPINbVWMAErACozjAUA), [6](https://tio.run/##y00syfn/v0RHMYAr1lbVnste1TaWK0BRp@T//2hjHQUTHQVTHQUzHQVzaxhDR8FCR8HSWgEoa6SjYGgApoytFSzBEuZgRabWMAbYCONYAA).
* Non-centrosymmetric: [1](https://tio.run/##y00syfn/v0RHMYAr1lbVnste1TaWK0BRp@T//2hDHQUjawUQGQsA), [2](https://tio.run/##y00syfn/v0RHMYAr1lbVnste1TaWK0BRp@T//2hDHQUjHQVDA2sFUx0FMx0FU2sFQ6hYLAA), [3](https://tio.run/##y00syfn/v0RHMYAr1lbVnste1TaWK0BRp@T//2hDEx0FUx0FYyNrBSMdBTMdBSDD2AAsZmgWCwA), [4](https://tio.run/##y00syfn/v0RHMYAr1lbVnste1TaWK0BRp@T//2hDSx0FCLZWMDHQUTAFYhNrBYRwLAA), [5](https://tio.run/##y00syfn/v0RHMYAr1lbVnste1TaWK0BRp@T//2hDHQUjIDLQUTCxVjDXUTDTAZEW1goWOlCumbWCsQ4IAdUZxgIA), [6](https://tio.run/##y00syfn/v0RHMYAr1lbVnste1TaWK0BRp@T//2hjHQUTHQVTHQUzHQVzaxhDR8FCR8HSGiplaABRhCGNojkWAA).
[Check](https://tio.run/##y00syfn/v0QnQJEr1lbVnste1TaWSzFAp@T//2h1kLC6tYI6SAZEgyRBNEhePRYA) that the program is centrosymmetric.
### Explanation
`%` is the comment symbol, which causes the rest of the line o be ignored. Newlines are also ignored. So the code is just
```
t,!P]=?P!,t
```
which does the following:
```
t       % Input, implicit. Duplicate
,       % Do twice
  !     %   Transpose
  P     %   Flip vertically
]       % End
=       % Compare element-wise
?       % If all comparisons gave true
  P     %   Implicit input. Transpose. Actually, since there is no more input, an
        %   error is prand the program exits. The rest of the code is not executed, 
        %   and will be described in parentheses
  !     %   (Transpose)
  ,     %   (Do twice)
    t   %     (Duplicate)
        %   (End, implicit)
        % (End, implicit)
```
[Answer]
# Haskell, size ~~11~~, ~~10~~, ~~9~~, 8
Takes the input as a 2D list! (Credit to Ørjan Johansen)
```
r= --r}-
 reverse
(==)<*> 
 r.map{-
-{pam.r 
 >*<)==(
esrever 
-}r-- =r
```
[Answer]
# [Python 2](https://docs.python.org/2/), size 8
```
i=input#
a=i()###
a[::-1##
]!=a<_##
##_<a=!]
##1-::[a
###)(i=a
#tupni=i
```
[Try it online!](https://tio.run/##NcwhEoAgEAXQ7i10CwYCRoY9iTDMNikrAYOnx@8o7aVX73acuvVeuGi9Gk3CxaxEwO69dUCaWUIGiHIQnhPgrPe7ALSawkC7quLofRlT1FFB/xV1ZFHH9urrXn0f9IfLAw "Python 2 – Try It Online")
Takes input as a 1D list of concatenated rows (of length \$n^2\$) and outputs via exit code (0 for symmetric inputs, 1 otherwise).
The list is simply checked to be a palindrome. If it is, the comparison chain `a[::-1]!=a<_` fails at the `!=` step and short-circuits; otherwise the unknown variable `_` gets evaluated, crashing the program.
[Answer]
# [R](https://www.r-project.org/), size 9
```
   #)x-))
#(nacs-<x
#(ver(yna
#       #
#       #
#       #
any(rev(#
x<-scan(#
))-x)#   
```
[Try it online!](https://tio.run/##bcq7CsAgDEbh3af4IUsyZKu9gC8TiquDgujTp5auPdM3nOoOgGSoSCAudjdNY6nnyrNYIHzRr6xMrrkzhZG03VaWRHTIu3jEiQM7LkRs/gA "R – Try It Online")
The last three lines are the actual program that takes a 1D array as input and checks if it's equal to its reverse. Truthy value: FALSE, Falsy value: TRUE.
```
any(rev(x<-scan())-x)
```
## [R](https://www.r-project.org/) + pryr, size 9
```
pryr::f(#
any(rev(#
x)-x))#  
  #))x-)x
#(ver(yna
#(f::ryrp
```
[Try it online!](https://tio.run/##DcshCsAwDEZh31MEYvKLirkRdpkyGjlKRElPn@WpzzxPe3ouP65qwm18R3zuUqAHwEStImIgOqKx7OlyvlEy1RpXmrxy6Q3kDw "R – Try It Online")
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), score 13 11 10
```
l=>a=>a.//
Where((e//
,i)=>e!=//
a[l-i-1]//
).Any()///
///()ynA.)
//]1-i-l[a
//=!e>=)i,
//e((erehW
//.a>=a>=l
```
[Try it online!](https://tio.run/##pVJRb9MwEH7Pr/iWJxtcV6UbTAwHVZV4AgmJSX2o8mCy22qR2sL2gDDlt3eXtNsqkACJiyN9dz5/3519TZo0IdLuNjl/g09dyrTV753/elEUTWtTwsfirgBbyja7BpHsVfBt95D77tY3b5zP6tfAulb4HEJbVbiG2bWmsrz0dFqsNhRJCGKonDQVnRiGdt1O3GRWM5R64Tshpwz5F7LzCy0Z1jPOaNeWoTmhykinGA5UkTYrhtpWhle7w8G4i6PavwV3hQ/WeZFy5H7XNWy8SXLM2Xc52FC8qpEpZRh4@v4QueNvpvBCYa5wil6xf6bwUuGVwvnePx8dDp3t/dMxmY/M0KO/eBRZbqj5cskSYtBhOvm090flY9mDxj8JzP9bYP53gXGz//3Sn3KPLlcN4kjuJ0mY6pH3MEfL4FNoSa@iy8QTSaIcCLC1/HY/4BJKPIe4FgPBs5FlLEQvbcrDAFZC6suwiNHyLEm8RemDn5R4jbKUfLRsyOcYUrfdElM2uuQG@t09 "C# (.NET Core) – Try It Online")
Takes input as 1D array and n2 as length; returns `false` for centrosymmetric and `true` for non-centrosymmetric. This version uses `System.Linq` but I don't know how to fit it in the code submission due to the particular requirements of the challenge. Unrolled code:
```
l => a => a.Where((e,i) => e != a[l-i-1]).Any()
```
Following is my previous submission that does not use LINQ:
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), score 16 15 13
```
l=>a=>{/////*
var r=1<2;for
(int i=0;i<l;
)r&=a[i]==a[l
-i++-1];
return r;}
     /*/
   };r nruter
     ;]1-++i-
l[a==]i[a=&r)
;l<i;0=i tni(
rof;2<1=r rav
*/////{>=a>=l
```
[Try it online!](https://tio.run/##pVJRa9swEH7Xrzj8UOxYduqk3cpkeYzAnlYYrLCH4AfNVToxRWInJVsW/Nuzs5O2YYNtsBMI3en0fXefrgtF51EfNsG4B/iwC1Gvy3fGfRWMdVaFAO/ZngFZiCqaDlCre@/s7jH37cZ1tXGR/xpYthw@eW@bBlYgD1Y2Sjb76WATtlUIKKt6JlYeWUrpYOSlMLUVLMMLqZamlbRbVpg8L6pWMNRxgw5Q9GM5MJ1Mh0MvEBxuosZjWLRVkeemYHappGwN7ReYMWFrIy6lgehMytCvxKyuJBWhtmwyFrVvpGqkPcDJSICztrfe3MOtMi4NEUmqZQsKH0I25hwFGmzom7cQdYggwelvj5E9rYrDjMOcwxX0nPxrDi84vORwc/RvRodC10f/akymJxX01OcTyeKz7r7cEUU68BBc9nz3R@Zz2hPHPxHM/5tg/neC8bL/XfTn3DNx@UAOwfzQGcjmCfc0ggvvgre6/IgmahpmnSYDAKwV/d13MAESyCFdpQPAZEQZCykXKsRhdps0K@/8G0S1S7MMXkOSwCtInHdFktHTpNMuog@79VoTZFcm1EB/@Ak "C# (.NET Core) – Try It Online")
Unrolled code:
```
l => a =>
{
    var r = 1<2;
    for (int i = 0; i < l;)
        r &= a[i] == a[l-i++-1];
    return r;
}
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), score ~~9~~ 8
```
->z{z==#
z.######
reverse#
}#######
#######}
#esrever
######.z
#==z{z>-
```
[Try it online!](https://tio.run/##pVPbboIwGL7vU/wpN1tWGg6KugRvdr8XIGRxrGQmCqaFJaI@O6MnRWPdxUho@5@/8n3w9nPfl2nvL7tDl6Ye6qinHsTZD@OCeejkGY/ZT8hjQkWNh3bIS9Ohfun3u7YRgN9Y1fBa7Ldb1vB18YqR8pdZloUEopxAFhEI85yWm1XTsCq/TiAQy5wpgYTAVB5j5XVUBEPSUBKYvokZEWt/GDiqAhnTi0xX5@mNfU54AJXA5IJ2RmAurbk6WvgTlea8gWyhsMoG170ILEb3Dy4fZ6GCoxnmqFrF4zHnOQgAW6IxkZZlW1uWcm1Z3rVlyTeWUcA4RjtjGS1glNPtanc4btYVO4JcafG94uJ0hkab@kPAC2B4EnXLCwZF/cWesYasceP3uvKLvwWldjdLYXCjqDB8JClNRxw5JJXcrxo40a/i3MhJiWMUcmOMbPbsvpQSo4T/SWli/gqd6FLbqMllTP8L "Ruby – Try It Online")
A lambda taking a flattened matrix as input. Returns true for centrosymmetric, false otherwise.
-1 thanks to Mr.XCoder,
Unpacked:
```
->z{
  z == z.reverse
}
```
[Answer]
# [Clean](https://github.com/Ourous/curated-clean-linux), size 9
Thanks to [Ørjan Johansen](https://codegolf.stackexchange.com/users/66041/%C3%98rjan-johansen)!
```
import //
 StdEnv//
r=reverse
?m=m==r//
    m    
//r==m=m?
esrever=r
//vnEdtS 
// tropmi
```
[Try it online!](https://tio.run/##TYyxDsIwDET3fIU/wCjQQilD1IUOSGwdEUPUBhSpTisnVOLnCWkGhIfz6d7p@tFoF2kaXqMB0tZFS/PEAaQU0IWhdUtyrNgshr0RDSlSileajlYRUrJKKTXC@NxTnLLFtUPoVgqBp5ls7IJOwwoauJUIe4QDQoVw/DM1wgkh0QJht82vzFGdcZWrP5Mmynv89I9RP33cXK7x/HaabO@/ "Clean – Try It Online")
# [Clean](https://github.com/Ourous/curated-clean-linux), size 10
```
import/*//
*/StdEnv//
r =reverse
?m      //
 =m==r m//
//m r==m= 
//      m?
esrever= r
//vnEdtS/*
//*/tropmi
```
[Try it online!](https://tio.run/##TYw9C8IwEIb3/op3LpGo9XMIXXQQHISO4hDaKIVeWq6x4J83HhHEW@55P@7qzlkfqW@enQPZ1seWhp6DzrXOcl2F5ugnQYZhNzkeXVYS0ogLQ8YwSFBrAhvREPwWqMzcmK4MWNzJH5tQ6Vww14H7gdpYBcsBBiWuhcJKYa2wUdj@wU5hryDpUmExT6tI1i7Fm1T9gbwobvFd3zv7GOPsdI6Hl7fU1l9x6Wy490wf "Clean – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), size 3 (11 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage))
```
ÂQq
   
qQÂ
```
Input as a single list.  
[Try it online.](https://tio.run/##MzBNTDJM/f//9JzDTYFchQqFXIGHm07P@f8/OtpYR8FER8FUR8FMR8E8VkchGsrUUbDQUbAECQBVGOkoGBqAKWOQiCVY0hys0BQkAGWCjTKOjQUA)
I guess this one doesn't count.. ;p
```
ÂQ
qâ
```
Input as a single list.  
[Try it online.](https://tio.run/##MzBNTDJM/f//cFMgV@HhRf//RxvrKJjoKJjqKJjpKJgjMSx0FCx1FICyRjoKhgZgyhgsZAGWNgMrhTOARhjHAgA)
**Explanation:**
```
Â         # Bifurcate this list (short for DR: Duplicate & Reverse copy)
 Q        # Check if the input-list and the reversed list are equal
  q       # Terminate the program
   qQâ    # No-ops
```
---
**Some size 3 (11 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)) alternatives:**
```
R€R
QqQ
R€R
```
Matrix as input.  
[Try it online.](https://tio.run/##MzBNTDJM/f8/6FHTmiCuwMJALjDr///oaGMdBRMdBVMdBTMdBfNYHYVoKFNHwUJHwRIkAFRhpKNgaACmjEEilmBJc7BCU5AAlAk2yjg2FgA)
```
RQ 
 q  
 QR
```
Single list as input.  
[Try it online.](https://tio.run/##MzBNTDJM/f8/KFCBS6EQiAOD/v@PNtZRMNFRMNVRMNNRMEdiWOgoWOooAGWNdBQMDcCUMVjIAixtBlYKZwCNMI4FAA)
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 12 x 12
```
C(e,n,t,r)//
int*e;{for//
(r=t=0;e[t//
];r|=e[t]^//
e[~t+++n])//
;n=!!!!r;}//
//};r!!!!=n;
//)]n+++t~[e
//^]t[e=|r;]
//t[e;0=t=r(
//rof{;e*tni
//)r,t,n,e(C
```
[Try it online!](https://tio.run/##vZRNb4JAEIbP9VesNk0WnIZFPqzZkB7stTdvFJNGl4ZDV7PdnhD/Oh1ALSoaa4kENvsuM/MM7Auzx4/ZLM/HVIAEDcqwrE4itSl4Gi8UCqoCHTAuQo0i4moV4DSaohDhWvf7fRkVOVwGXTwUz1BYVsZVIQPJURiRxDi9DgWKaaRDEawUj1DglDOsrygKtYhTLkwtkyJHYTcSBB3n93MRJ1KQCX2FF@xwqbDBmPYe5iR4JsVIug/zN9mDcRFhQFdhFO98vieSGmnnbkIpxZQwMlJCiA1kAMQB4gLxgPhAhkCeynNYSq@85ZRhNjl/AMsMDDcxwTZOkrxt3cuKniE5plORlt/6i/Z6@JiN0GspjdCBObj14x2QWFWelfX9ilut2axlEoPDwTtewuHfpJvZ8IBRh412ALZtZ7Tfwl4vO5JnehfZsBjbtSE78SI3Fql6te1rjVjbsgZS9RqdQYMN/XZJuAvby91Y0IXacnuk6ndR1R82@dAvbXGRD2s2ZH@0obv5mrezY5f@Ju/bEElZ/gM "C (gcc) – Try It Online")
[Answer]
# ><>, Size 6
```
!/l2(\
s\?\ ?
/{=/ ;
: /={/
? \?\s
\(2l/!
```
[Try it online!](https://tio.run/##S8sszvj/X1E/x0gjhqs4xj5GwZ5Lv9pWX8Gay0pB37Zan8teAShazBWjYZSjr/j//3/dMgVDEGEEJwwB "><> – Try It Online")
(It turns out it's a pain passing multiple value to -v in tio)
Input is taken as a one dimensional array as the initial stack state with -v. Exits with no output if the matrix is centrosymmetric, exits with an error (prints "Something smells fishy...") if not. 
```
l2(    Checks if the length of the stack is less than 2
?;     Exits cleanly if so
{=     Checks if the first and last elements are equal
?\s    Causes an error ('s' is not a valid instruction) if not
```
I wasn't entirely happy with this output format, so here's a size 7 one which outputs 1 for true, and 0 for false. 
```
!/l2(\\
 ?   ?0
 =;n1/n
;{   {;
n/1n;= 
0?   ? 
\\(2l/!
```
[Try it online!](https://tio.run/##S8sszvj/X1E/x0gjJoZLwV5BQcHegEvB1jrPUD@Py7oayK@25srTN8yztlXgMgDLK3DFxGgY5egr/v//X7dMwRBEGMEJQwA "><> – Try It Online")
[Answer]
# [Stax](https://github.com/tomtheisen/stax), n = 3
```
$cr
=q=
rc$
```
[Run and debug it](https://staxlang.xyz/#c=%24cr%0A%3Dq%3D%0Arc%24&i=[[1,+2],+[2,+1]]%0A[[1,+2,+3],+[5,+6,+5],+[3,+2,+1]]%0A[[10,+5,+30],+[2,+6,+2],+[30,+5,+10]]%0A[[100,+100,+100],+[100,+50,+100],+[100,+100,+100]]%0A[[1,+2,+3,+4],+[5,+6,+7,+8],+[8,+7,+6,+5],+[4,+3,+2,+1]]%0A[[3,+4,+5,+6,+7],+[5,+6,+7,+8,+9],+[3,+2,+10,+2,+3],+[9,+8,+7,+6,+5],+[7,+6,+5,+4,+3]]%0A%0A[[1,+2],+[1,+2]]%0A[[1,+2,+10],+[5,+6,+5],+[11,+2,+1]]%0A[[14,+5,+32],+[2,+6,+2],+[30,+5,+16]]%0A[[19,+19,+19],+[40,+50,+4],+[19,+19,+19]]%0A[[1,+2,+20,+4],+[7,+6,+7,+8],+[8,+7,+6,+6],+[3,+3,+2,+1]]%0A[[3,+4,+5,+6,+7],+[5,+6,+7,+8,+9],+[4,+5,+10,+4,+5],+[5,+6,+7,+8,+9],+[3,+4,+5,+6,+7]]&m=2)
Explanation:
```
$cr =q= rc$ Full program, implicit input
$           Flatten
 cr         Copy and reverse
    =       Compare to original
     q      Print result
      =     Silently error because there is only one item on stack
        rc$ Not executed
```
3 is the best possible because I need at least three commands: Copy,
reverse, and compare
### [Stax](https://github.com/tomtheisen/stax), n = 4
```
Mrxr
M=qX
Xq=M
rxrM
```
[Run and debug it](https://staxlang.xyz/#c=Mrxr%0AM%3DqX%0AXq%3DM%0ArxrM&i=[[1,+2],+[2,+1]]%0A[[1,+2,+3],+[5,+6,+5],+[3,+2,+1]]%0A[[10,+5,+30],+[2,+6,+2],+[30,+5,+10]]%0A[[100,+100,+100],+[100,+50,+100],+[100,+100,+100]]%0A[[1,+2,+3,+4],+[5,+6,+7,+8],+[8,+7,+6,+5],+[4,+3,+2,+1]]%0A[[3,+4,+5,+6,+7],+[5,+6,+7,+8,+9],+[3,+2,+10,+2,+3],+[9,+8,+7,+6,+5],+[7,+6,+5,+4,+3]]%0A%0A[[1,+2],+[1,+2]]%0A[[1,+2,+10],+[5,+6,+5],+[11,+2,+1]]%0A[[14,+5,+32],+[2,+6,+2],+[30,+5,+16]]%0A[[19,+19,+19],+[40,+50,+4],+[19,+19,+19]]%0A[[1,+2,+20,+4],+[7,+6,+7,+8],+[8,+7,+6,+6],+[3,+3,+2,+1]]%0A[[3,+4,+5,+6,+7],+[5,+6,+7,+8,+9],+[4,+5,+10,+4,+5],+[5,+6,+7,+8,+9],+[3,+4,+5,+6,+7]]&m=2)
Explanation:
```
Mrxr M=qX Xq=M rxrM Full program, implicit input
Mr                  Transpose and reverse
  x                 Push input again
   r M              Reverse and transpose
      =             Compare
       qX Xq        Print result twice and save to X
            =       Silently error because there is only one item on stack
             M rxrM Not executed
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), size 2 (5 bytes)
```
ê"
"ê
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.6&code=6iIKIuo=&input=WzEsMiwzLDQsNSw0LDMsMiwxXQ==)
[Answer]
# Java 10, size 13 (181 bytes)
```
a->{var r///*
=1>0;for(int 
l=a.length,i=
0;i<l;)r&=a[i
]==a[l-++i]; 
return r;}   
     /*/     
   };r nruter
 ;]i++-l[a==]
i[a=&r);l<i;0
=i,htgnel.a=l
 tni(rof;0>1=
*///r rav{>-a
```
[Try it online.](https://tio.run/##rVRNj9owEL37V4z2sEogn8BCqdcceuite2FvKAcTDHjrdVaOQ4VQfjudGNiuL9tGqpLJaBLPx5sXvRd@4PHL5ue5VLyu4QeX@kQApLbCbHkp4KkLAdZVpQTXUAbroxWrAnhI8UNL8FFbbmUJT6CBwZnHi9OBGzBpmg4IyxcZ3VYmwIpAFOOJEnpn95FkJKPyUdHQ3DO@kqRg6FQ8HMqCAjHCNkaDoS02dxNAOkid76KWGtCmwSEJ0EIOh7FaccYKItHdm5CqR0kzwmS0tzstVMKZImC1DEy1pdkiZ2SA8@GU/HBaxPxMOyBvzVohkCueQyU38IoLCZbWSL1zoC/bSFN4xu7741cXLo@1Fa9J1djkDU9apQOdlIEWv@CyrVMejfDK29Bt7V8zxtFDNEUb983NuqQMs6ZdlS7Ks175WfTRHvwQrTeQiYMyi77gNXOgJr1h/alyqzW/1Mhci/l76fcGnxUPHeWOy@9c1aIXl2g9V@A46cbK875sdqjHI4/NaZ/8eXS5J47JSXR70RPBqMudeSxOce3/g8WJ@0Od@0jt9eBfWLxpQsfksmoMilZZbcSndN55KuWJlKdRnkR5CuUJlKdPnjx56uSJk6dNnjR5ynSX7IT9hqurgzC8am57/g0)
Inspired by [*@Charlie*'s C# answer](https://codegolf.stackexchange.com/a/168715/52210).
**Golfed explanation:**
```
a->{var r=1>0;for(int l=a.length,i=0;i<l;)r&=a[i]==a[l-++i];return r;}
a->{                    //  Method with byte-array parameter and boolean return-type
  var r=1>0;            //  Result-boolean, starting at true
  for(int l=a.length,   //  The length of the input-array
      i=0;i<l;)         //  Loop `i` in the range [0, length)
    r&=                 //   Bitwise-AND the result-boolean with:
       a[i]             //    Whether the current item
           ==a[l-++i];  //    equals the opposite item
  return r;}            //  Return the result
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), score 11
Takes a list of int and n as arguments. Returns n as truthy value, 0 as falsy.
```
/*//};n=l;k
--*==++l*=*
n);l>k;n*n+
l=k(rof{;l*
tni)n,l(f;k
*/*/////*/*
k;f(l,n)int
*l;{for(k=l
+n*n;k>l;)n
*=*l++==*--
k;l=n;}//*/
```
[Try it online!](https://tio.run/##jVLdboIwGL2mT9GYLGkLjfyJc0293BPsbu7CuLAZurogXiyEZ2f9oQNUdAYL6Tnn6/lOvx392O3adk7m84ZJLlgBKCWc@74gnACJmVgXTBLpA8ELVB7ymgkCKrnHMhAoV3yixeqn3qBgORKBxHtZASJYnR9KVHABfFWBFWvBsASqrvB9zgmlii@4ZI0Wt0oDv7Z7iTCogacreF5VnqrPn@j1DXJYRwGMzRM1wR8WD7EkgIsAZmZNLqhJRw0tHhpCZoV2LwoH9NTRQw2MlsXllloG2sWZq9QZWwbw0TxL5zO9ZjWz@jPlsMTqTxa6Q1bjwqMTGgY8F2q@Fcdxpno1pxtoFGmXlq0URQOnhusytTaT@EqmWc92kSqn7p92cab9VrTqFaMgY8tbXksyMxEk5/7@FWTaXb77usy5F9sgv0/VEc1ezF09bSSldCNn2EKlSjlHs4d3tRXAHHUzrJxhzZjAdWC38OQOnt7B9RzcwvUFYzxobiOfdYD3urPDNNmcHahJb3aGbsPpbXi6MTsAXV9N@ws "C (gcc) – Try It Online")
[Answer]
# Javascript ES6, size 8:
```
/***/a=>
""+a==a.
reverse(
)/////*/
/*/////)
(esrever
.a==a+""
>=a/***/
```
# Javascript ES6, size 7 (is it valid?):
```
a=>""+a
==a.//=
reverse
`     `
esrever
=//.a==
a+"">=a
```
### Test:
```
<script>
f=
a=>""+a
==a.//=
reverse
`     `
esrever
=//.a==
a+"">=a
</script>
<script>
console.log([
  [1, 2, 2, 1],
  [1, 2, 3, 5, 6, 5, 3, 2, 1],
  [10, 5, 30, 2, 6, 2, 30, 5, 10],
  [100, 100, 100, 100, 50, 100, 100, 100, 100],
  [1, 2, 3, 4, 5, 6, 7, 8, 8, 7, 6, 5, 4, 3, 2, 1],
  [3, 4, 5, 6, 7, 5, 6, 7, 8, 9, 3, 2, 10, 2, 3, 9, 8, 7, 6, 5, 7, 6, 5, 4, 3],
].every(f))
console.log([
  [1, 2, 1, 2],
  [1, 2, 10, 5, 6, 5, 11, 2, 1],
  [14, 5, 32, 2, 6, 2, 30, 5, 16],
  [19, 19, 19, 40, 50, 4, 19, 19, 19],
  [1, 2, 20, 4, 7, 6, 7, 8, 8, 7, 6, 6, 3, 3, 2, 1],
  [3, 4, 5, 6, 7, 5, 6, 7, 8, 9, 4, 5, 10, 4, 5, 5, 6, 7, 8, 9, 3, 4, 5, 6, 7],
].every(x=>!f(x)))
</script>
```
or with lambda saved to variable named `a`:
```
a=
a=>""+a
==a.//=
reverse
`     `
esrever
=//.a==
a+"">=a
console.log([
  [1, 2, 2, 1],
  [1, 2, 3, 5, 6, 5, 3, 2, 1],
  [10, 5, 30, 2, 6, 2, 30, 5, 10],
  [100, 100, 100, 100, 50, 100, 100, 100, 100],
  [1, 2, 3, 4, 5, 6, 7, 8, 8, 7, 6, 5, 4, 3, 2, 1],
  [3, 4, 5, 6, 7, 5, 6, 7, 8, 9, 3, 2, 10, 2, 3, 9, 8, 7, 6, 5, 7, 6, 5, 4, 3],
].every(a))
console.log([
  [1, 2, 1, 2],
  [1, 2, 10, 5, 6, 5, 11, 2, 1],
  [14, 5, 32, 2, 6, 2, 30, 5, 16],
  [19, 19, 19, 40, 50, 4, 19, 19, 19],
  [1, 2, 20, 4, 7, 6, 7, 8, 8, 7, 6, 6, 3, 3, 2, 1],
  [3, 4, 5, 6, 7, 5, 6, 7, 8, 9, 4, 5, 10, 4, 5, 5, 6, 7, 8, 9, 3, 4, 5, 6, 7],
].every(x=>!a(x)))
```
[Answer]
# Clojure, Size 9
```
#(= %(;;;
reverse;;
(map;;;;;
reverse;;
%)));)))%
;;esrever
;;;;;pam(
;;esrever
;;;(% =(#
```
[Try it online!](https://tio.run/##lVJNj4MgEL3zKyZpTDDh4HfbkKa3/QV7Mx4aS7M2ahukm/jrXRhoxe562AM6PN68GR5Tt7frQ4qJnsUFatEreRvGrhNKNvVx2tADBJRzTqT4FnIQOqLd6c75EgvCMOR6BYRzMSBOkHM/dXSJ0QAOdDOFhGBJJR/qayQlKcuYQVIxKBMGcVU5gEFqsJxBwSA3YYqoY0Qa1JTI5RVOIrV4HDlWZGL7MccY52/7F8ErzSCbq28Z7Mxuh@GznQxpr45MCtY2CctcBnuv/2i@3B4PPU0XolSqZaunW5dTO4ilW/ifW46jN7vi2PfL9pYmK34VlqUbsgsv6LxCJ7yjuWbyPN3@7VPhrv0/nzL3hJa4ZqUn4vmkxKA@7WQBUDN64xGasx7vRo1gJvjXrLtJ1EM8S3xYu2eJ/qZWsu3LmGxC77LpVdt7XYRL0OqG0w8 "Clojure – Try It Online")
]