Es gibt eine Art n × n Matrix W, die als kanonische Grundform von Weyr bezeichnet wird . Eine solche Matrix wird durch ihre Blöcke beschrieben und hat die folgenden Eigenschaften unter Verwendung des folgenden Referenzdiagramms:

• die Hauptdiagonalblöcke W _ii sind n _i × n _i Matrizen der Form λ I _{n i,} wobei I _{n i} die Identitätsmatrix n _i × n _i ist.
• n ₁ ≥ n ₂ ≥ ... ≥ n _r
• Die ersten superdiagonalen Blöcke W _{k-1, k} für k ∈ 2..r sind n _k-1 × n _k Matrizen, die den vollen Spaltenrang in zeilenreduzierter Staffelform haben , oder einfacher gesagt, I _{n k,} die oben aufliegen n _k-1 - n _k Reihen von Nullen.
• Alle anderen Blöcke sind 0 Matrizen.

Beispielsweise:

• Die diagonalen Hauptblöcke (gelb) sind so, dass die n _i 4, 2, 2 und 1 sind.
• Die ersten superdiagonalen Blöcke sind grün.
• Die graue Zone besteht aus allen anderen Blöcken, die alle 0 sind .

Für diese Herausforderung nehmen wir λ = 1 an.

Eingang

Eine quadratische Matrix mit Nullen und Einsen in einem beliebigen Format.

Ausgabe

Geben Sie einen von zwei unterschiedlichen Werten aus, ob die Eingabematrix Weyr ist oder nicht.

Regeln

Das ist Code-Golf . In jeder Sprache gewinnen die wenigsten Bytes. Es gelten Standardregeln / Regelungslücken.

Testfälle

Präsentiert als Arrays von Zeilen.

Weyr:

[[1]] 
[[1,1],[0,1]] 
[[1,0,1,0,0],[0,1,0,1,0],[0,0,1,0,1],[0,0,0,1,0],[0,0,0,0,1]]
[[1,0,0,1,0,0,0,0,0],[0,1,0,0,1,0,0,0,0],[0,0,1,0,0,1,0,0,0],[0,0,0,1,0,0,1,0,0],[0,0,0,0,1,0,0,1,0],[0,0,0,0,0,1,0,0,1],[0,0,0,0,0,0,1,0,0],[0,0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,0,1]]
[[1,0,0,0,1,0,0,0,0],[0,1,0,0,0,1,0,0,0],[0,0,1,0,0,0,0,0,0],[0,0,0,1,0,0,0,0,0],[0,0,0,0,1,0,1,0,0],[0,0,0,0,0,1,0,1,0],[0,0,0,0,0,0,1,0,1],[0,0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,0,1]]

Nicht-Weyr:

[[0]]
[[1,0],[1,1]]
[[1,0,0,1,0,0],[0,1,0,0,0,0],[0,0,1,0,0,1],[0,0,0,1,0,0],[0,0,0,0,1,0],[0,0,0,0,0,1]]
[[1,0,1,0,0],[0,1,0,0,0],[0,0,1,0,0],[0,0,0,1,0],[0,0,0,0,1]]
[[1,0,0,1,0,0,0,0,0],[0,1,0,0,1,0,0,0,0],[0,0,1,0,0,1,0,0,0],[0,0,0,1,0,0,0,0,0],[0,0,0,0,1,0,1,0,0],[0,0,0,0,0,1,0,1,0],[0,0,0,0,0,0,1,0,1],[0,0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,0,1]]

K (ngn / k) , 91 88 84 80 Bytes

{x~e|(-n)#'(0*x),'(!n)=\:,/(-1_b)+1_0{x#!y}':|-n-':|b:|\@[-1++/|\|+x|e:=n:#x]\0}

Probieren Sie es online!

Python 2 , 270 Bytes

lambda m,w=0:{w}&{0,len(m)}and I(m)or any(I([l[:i]for l in m[:i]])*I([l[i:j+i]for l in m[:j]])*(sum(sum(m[:i]+[l[:i]for l in m],[]))==2*i+j)and f([l[i:]for l in m[i:]],j)for i in range(w,len(m))for j in range(1,i+1))
I=lambda m:all(sum(l)==l[i]>0for i,l in enumerate(m))

Probieren Sie es online!

Erläuterung:

Überprüft Blöcke rekursiv auf Identität und ihre überdiagonalen Blöcke.

I prüft, ob eine Matrix eine Identitätsmatrix ist

I=lambda m:all(sum(l)==l[i]>0for i,l in enumerate(m))

Für jeden Block der Eingabematrix prüft die Funktion, ob es sich um eine Identität handelt und ob rechts davon ein weiterer Identitätsmatrixblock vorhanden ist. Die nächste Iteration betrachtet dann einen Block dieser Größe.

{w}&{0,len(m)}and I(m)                # if the while matrix is an identity matrix,
                                      # return true (but only the first time or last block)
or
any(
 I([l[:i]for l in m[:i]])                         # the current block is identity
 *I([l[i:j+i]for l in m[:j]])                     # and, the smaller block to the right is identity
 *(sum(sum(m[:i]+[l[:i]for l in m],[]))==2*i+j)   # and everything below and to the right (not the
                                                  # smaller block), are 0
 and f([l[i:]for l in m[i:]],j)                   # and the remaining matrix is alse Weyr(recursively)
 for i in range(w,len(m))             # for each block size i
 for j in range(1,i+1)                # for each smaller right block of size j
)