(inspirado por esta pregunta sobre matemáticas)

Las definiciones

Dada una n x nmatriz cuadrada A , podemos llamarla invertiblesi existe alguna n x nmatriz cuadrada B tal que AB = BA = I _n , siendo I _n la matriz de identidad de tamaño n x n(la matriz con la diagonal principal 1sy cualquier otra cosa 0), y AB y BA que representa la multiplicación matricial habitual (no voy a entrar en eso aquí, vaya a tomar una clase de álgebra lineal).

A partir de eso, podemos llamar a una m x nmatriz C totally invertible si cada k x ksubmatriz (que se define más adelante) de C es invertible para todos k > 1, k <= (smaller of m,n).

Una submatriz se define como la matriz resultante después de la eliminación de cualquier número de filas y / o columnas de la matriz original. Por ejemplo, la siguiente 3x3matriz C se puede transformar en una 2x2submatriz C ' eliminando la primera fila 1 2 3y la columna central de la 2 5 8siguiente manera:

C = [[1 2 3]
     [4 5 6]    -->  C' = [[4 6]
     [7 8 9]]              [7 9]]

Tenga en cuenta que hay muchas posibilidades de submatrices diferentes, lo anterior es solo un ejemplo. Este desafío solo se refiere a aquellos en los que la submatriz resultante es una k x k matriz cuadrada .

El reto

Dada una matriz de entrada, determine si es totalmente invertible o no.

La entrada

• Una única matriz de tamaño m x n, en cualquier formato adecuado .
• Sin pérdida de generalidad, puede asumir m <= no m >= n, lo que sea más golfista para su código, y tomar la entrada de esa manera (es decir, obtiene una operación de transposición de forma gratuita si lo desea).
• El tamaño de la matriz de entrada no será menor 3 x 3ni mayor que el que pueda manejar su idioma.
• La matriz de entrada consistirá solo en valores numéricos de Z ⁺ (los enteros positivos ).

La salida

• Un valor verdadero / falso para determinar si la matriz de entrada es totalmente invertible.

Las normas

• Un programa completo o una función son aceptables.
• Las lagunas estándar están prohibidas.
• Este es el código de golf, por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes).

Los ejemplos

Truthy

[[1 2 3]
 [2 3 1]
 [3 1 2]]

[[2 6 3]
 [1 12 2]
 [5 3 1]]

[[1 2 3 4]
 [2 3 4 1]
 [3 4 1 2]]

[[2  3  5  7  11]
 [13 17 19 23 29]
 [31 37 41 43 47]]


Falsey

[[1 2 3]
 [4 5 6]
 [7 8 9]]

[[1 6 2 55 3]
 [4 5 5 5  6]
 [9 3 7 10 4]
 [7 1 8 23 9]]

[[2 3 6]
 [1 2 12]
 [1 1 6]]

[[8 2 12 13 2]
 [12 7 13 12 13]
 [8 1 12 13 5]]

Gelatina , 26 24 23 20 19 17 16 bytes

-1 byte gracias a @miles (innecesario para cada uno €, al tomar determinantes)
-2 bytes, ¡@miles nuevamente! (separación innecesaria de la cadena y uso Ѐrápido)

ZœcLÆḊ
œcЀJÇ€€Ȧ

TryItOnline! o las 8 pruebas

¿Cómo?

œcЀJÇ€€Ȧ  - Main link: matrix as an array, M
    J      - range of length -> [1,2,...,len(a)] (n)
  Ѐ       - for each of right argument
œc         -     combinations of M numbering n
     Ç€€   - call the last link (1) as a monad for €ach for €ach
        Ȧ  - all truthy (any determinant of zero results in 0, otherwise 1)
                 (this includes an implicit flattening of the list)

ZœcLÆḊ - Link 1, determinants of sub-matrices: row selection, s
Z      - transpose s
   L   - length of s
 œc    - combinations of transposed s numbering length of s
    ÆḊ - determinant

Mathematica 10.0, 34 bytes

#~Minors~n~Table~{n,Tr@#}~FreeQ~0&

Una cadena de 6 tildes ... ¡nuevo récord personal!

MATL, 57 bytes

tZyt:Y@!"@w2)t:Y@!"@w:"3$t@:)w@:)w3$)0&|H*XHx]J)]xxtZy]H&

Por supuesto que puede probarlo en línea!

La entrada debe estar en orientación 'vertical' (nRows> = nColumns). Siento que esta puede no ser la solución más eficiente ... Pero al menos estoy dejando espacio para que otros me superen. Me encantaría escuchar sugerencias específicas que podrían haber acortado este enfoque en particular, pero creo que este bytecount masivo debería inspirar a otros a hacer una entrada MATL con un enfoque completamente diferente. Muestra 0 si es falso o un valor masivo si es verdadero (se convertirá rápidamente en Inf si la matriz es demasiado grande; por 1 byte adicional, uno podría reemplazar H*con H&Y(lógico y)). Guardado algunos bytes gracias a @LuisMendo.

tZy  % Duplicate, get size. Note that n=<m.   
%   STACK:  [m n], [C]
t: % Range 1:m                           
%   STACK:  [1...m], [m n], [C]
Y@   % Get all permutations of that range. 
%   STACK:  [K],[m n],[C] with K all perms in m direction.
!"   % Do a for loop over each permutation.
%   STACK:  [m n],[C], current permutation in @.
@b   % Push current permutation. Bubble size to top.
%   STACK:  [m n],[pM],[C] with p current permutation in m direction.
2)t:Y@!" % Loop over all permutations again, now in n direction
%   STACK: [n],[pM],[C] with current permutation in @.
@w:" % Push current permutation. Loop over 1:n (to get size @ x @ matrices)
%   STACK: [pN],[pM],[C] with loop index in @.
3$t  % Duplicate the entire stack.
%   STACK: [pN],[pM],[C],[pN],[pM],[C]
@:)  % Get first @ items from pN
%   STACK: [pNsub],[pM],[C],[pN],[pM],[C]
w@:) % Get first @ items from pM
%   STACK: [pMsub],[pNsub],[C],[pN],[pM],[C]
w3$)  % Get submatrix. Needs a `w` to ensure correct order.
%   STACK: [Csub],[pN],[pM],[C]
0&|  % Determinant.
%   STACK: [det],[pN],[pM],[C]
H*XHx% Multiply with clipboard H.
%   STACK: [pN],[pM],[C]
]    % Quit size loop
%   STACK: [pN],[pM],[C]. Expected: [n],[pM],[C]
J)   % Get last element from pN, which is n.
%   STACK: [n],[pM],[C]
]    % Quit first loop
xxtZy% Reset stack to
%   STACK: [m n],[C]
]    % Quit final loop.
H& % Output H only.