(inspirado por esta pergunta sobre matemática)

As Definições

Dada uma n x nmatriz quadrada A , podemos chamá-la invertiblese existir alguma n x nmatriz quadrada B, tal que AB = BA = I _n , com I _n sendo a matriz de identidade de tamanho n x n(a matriz com a principal diagonal se 1qualquer outra coisa 0), e AB e BA representando a multiplicação matricial usual (não vou entrar nisso aqui - faça uma aula de álgebra linear).

A partir disso, podemos chamar uma m x nmatriz C totally invertible se cada k x ksubmatriz (definido abaixo) de C pode ser invertida para todos k > 1, k <= (smaller of m,n).

Uma submatriz é definida como a matriz resultante após a exclusão de qualquer número de linhas e / ou colunas da matriz original. Por exemplo, a 3x3matriz C abaixo pode ser transformada em uma 2x2submatriz C ' removendo a primeira linha 1 2 3e a coluna do meio da 2 5 8seguinte maneira:

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

Observe que existem muitas possibilidades diferentes de submatrizes, o acima é apenas um exemplo. Esse desafio está relacionado apenas àqueles em que a submatriz resultante é uma k x k matriz quadrada .

O desafio

Dada uma matriz de entrada, determine se é totalmente invertível ou não.

A entrada

• Uma única matriz de tamanho m x n, em qualquer formato adequado .
• Sem perda de generalidade, você pode assumir m <= nou m >= n, o que for mais golfista para o seu código, e aceitar a entrada dessa maneira (ou seja, você obtém uma operação de transposição gratuitamente, se desejar).
• O tamanho da matriz de entrada não será menor que 3 x 3, nem maior do que o seu idioma pode suportar.
• A matriz de entrada será composta apenas por valores numéricos de Z ⁺ ( números inteiros positivos ).

A saída

• Um valor de verdade / falsey para saber se a matriz de entrada é totalmente invertível.

As regras

• Um programa completo ou uma função são aceitáveis.
• As brechas padrão são proibidas.
• Isso é código-golfe, portanto todas as regras usuais de golfe se aplicam e o código mais curto (em bytes) vence.

Os exemplos

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]]

Geléia , 26 24 23 20 19 17 16 bytes

-1 byte graças a @miles (desnecessário para cada um €, ao tomar determinantes)
-2 bytes, @miles novamente! (separação desnecessária de cadeias e uso Ѐrápido)

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

TryItOnline! ou todos os 8 testes

Quão?

œ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&

Uma cadeia de 6 til ... novo recorde pessoal!

MATL, 57 bytes

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

Claro, você pode experimentar online!

A entrada deve estar na orientação 'retrato' (nRows> = nColumns). Sinto que essa pode não ser a solução mais eficiente ... Mas pelo menos estou deixando espaço para que outras pessoas me superem. Eu adoraria ouvir dicas específicas que poderiam tornar essa abordagem específica mais curta, mas acho que esse enorme número de dados deve inspirar outras pessoas a fazer uma entrada no MATL com uma abordagem completamente diferente. Exibe 0 se falso, ou um valor maciço se for verdade (rapidamente se tornará Inf se a matriz for muito grande; por 1 byte extra, pode-se substituir H*por H&Y(lógico e)). Economizei alguns bytes graças 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.