# Is this a cube?

## Python, ^{262 \$\cdots\$ 305} 303 bytes

Saved a whopping 19 bytes thanks to dingledooper!!!

Added 118 bytes to fix a bug kindly pointed out by xnor, Peter Kagey and l4m2.

```
lambda l,R=range,L=len:(n:=L(l))<2or(d:=L(bin(n))-3)and(p:=sorted([sum((x-y)**2for x,y in zip(i,j))for i in l for j in l]))==[i*p[n]for i in R(d+2)for _ in R(2**d*math.comb(d,i))]and(K:=R(L(l[0])))and L({sum(([sum(l[i][j]for i in R(n))for j in K][j]-n*l[i][j])**2for j in K)for i in R(n)})<2
import math
```

Try it online!

Inputs a list of points and returns `True`

/`False`

.

**How**

Calculates the square of the distances between all possible pairs of points (including self-pairs and both \$(p_i,p_j)\$ and \$(p_j,p_i)\$ for all points \$p_j\$ and \$p_i\$ where \$i\neq j\$) and normalises them by the smallest non-zero square distance. For an \$n\$-cube we should then see a pattern of integers \$i = 0,1,\dots, n\$ each occurring \$2^{n}{n\choose i}\$ times. This corresponds with the \$0\$s for all the self-pairs, and the square of the lengths of all the sides being \$a^2\$, and the square of the lengths of all the diagonals being \$2a^2, 3a^2,\dots, na^2\$.

**Correction**

Also checks that the given vertices are all equidistant from the centre of mass.

## APL (Dyalog Unicode), 44 bytes

```
{≡/((÷∘⊃⍨1↓⍋⌷¨⊂)⍤1∘.(+.×⍨-)⍨)¨⍵(,⍳2⍴⍨⌊2⍟≢⍵)}
```

Try it online!

the argument `⍵`

is a vector of coordinate vectors

`,⍳2⍴⍨⌊2⍟≢⍵`

build a hypercube as the cartesian product \$\{0,1\}^{\left\lfloor \log_2\left|\omega\right|\right\rfloor}\$

`≡/(`

*f*`)¨⍵(`

..`)`

evaluate *f* for `⍵`

and the 01 hypercube, and test if they match

`∘.(+.×⍨-)⍨`

matrix of pairwise distances

`(÷∘⊃⍨1↓⍋⌷¨⊂)⍤1`

sort each row and divide by its second element

## Python 3, ^{339} 338

```
lambda P:1==L(P)or P in map(g,permutations(P))
from itertools import*
L=len
Z=zip
D=lambda a,b:sum(x*y for x,y in Z(a,b))
def g(Q):B=[[x-y for x,y in Z(p,Q[0])]for p in Q[3-L(bin(L(Q))):]];return any(D(a,b)or D(a,a)-D(b,b)for a,b in combinations(B,2))or{tuple(x+sum(y)for x,y in Z(Q[0],Z(*C)))for C in product(*[(p,(0,)*L(p))for p in B])}
```

Try it online!

Takes a `set`

of points as input.

Pseudocode explanation:

```
def f(points):
let n = log_2(|points|)
for each permutation Q of the points:
let q be the first point in Q
let B be the following n points, with q subtracted from each
if all pairs of points in B are orthogonal and have equal magnitude:
let S be the set of points which can be obtained by summing q and any subset of B
if S == points: return True
return False
```

Can definitely be golfed further but it's bedtime.