(a) A b
(b) E=b c
(c) A E
(d) F=D A
(e) G=A D
(f) F b
(g) Concatenar b, A^{T} (transposto) e novamente b, da esquera para a direita. Calcular a inversa da matriz resultante e atribuir à variável N
(h) Posto da matriz M [dica: função rank]
(i) \operatorname{det}(M) [dica: função det]
(j) Autovalores e autovetores de M [dica: função eig]
(k) M b
(l) M^{-1} [dica: função inv]
(m) X=N M
(n) X^{2}
(o) Seja a matriz P onde seus elementos p_{i j}=m_{i j}^{2} (cada elemento de P é igual ao quadrado do elemento correspondente da matriz M )
Passo 1
O enunciado pede que a gente crie um script que execute várias operações matriciais sobre as matrizes abaixo e justifique quando alguma operação der erro. As matrizes fornecidas são (vou escrever exatamente os valores dados):
As operações pedidas são (vou listar as perguntas exatamente para não nos perder):
(a) A b
(b) E=b c
(c) A E
(d) F=D A
(e) G=A D
(f) F b
(g) Concatenar b, A^{T} e b (da esquerda para a direita) e calcular a inversa da matriz resultante, atribuindo à variável N
(h) Posto (rank) da matriz M
(i) \det(M)
(j) Autovalores e autovetores de M
(k) M b
(l) M^{-1}
(m) X=N M
(n) X^{2}
(o) A matriz P em que cada elemento é p_{ij}=m_{ij}^{2}
No Passo 2 em diante eu executo passo a passo cada operação, ensino a teoria necessária e justifico erros quando existirem.]
Passo 2
Conceitos básicos que vamos usar (curtinho e prático, para a prova):
Multiplicação de matrizes: para multiplicar A (de dimensão m\times n) por B (de dimensão n\times p) é necessário que o número de colunas de A (que é n) seja igual ao número de linhas de B (também n). O resultado tem dimensão m\times p. Cada componente resultante é soma de produtos correspondente.
Produto externo: se b é m\times 1 e c é 1\times p, então b c é uma matriz m\times p com entradas (b c)_{ij}=b_i c_j.
Transposta: A^{T} troca linhas por colunas; se A é r\times s, então A^{T} é s\times r.
Inversa: Uma matriz quadrada S tem inversa S^{-1} somente se for quadrada e tiver determinante diferente de zero; se duas colunas (ou linhas) são iguais, S é singular e não tem inversa.
Posto (rank): é o número máximo de colunas (ou linhas) linearmente independentes; computa-se por eliminação gaussiana ou função rank.
Determinante e autovalores/autovetores: para matriz quadrada M, \det(M) indica invertibilidade; autovalores \lambda e autovetores v satisfazem M v=\lambda v. Na prática usamos funções numéricas (por ex. eig em MATLAB/Python) para obter valores aproximados.
Produto elemento a elemento (para o item (o)): dado M, a matriz P com p_{ij}=m_{ij}^{2} é o quadrado elemento a elemento (em MATLAB/Python: P = M.^2 ou P = np.square(M)).
Agora vamos aplicar item a item com contas detalhadas quando possível e com as linhas de script recomendadas.
Passo 3
(a) Calcular A b.
Dimensões: A é 2\times 4, b é 4\times 1 → compatível, resultado será 2\times 1.
Cálculo pelo método padrão (cada entrada é soma dos produtos correspondentes):
Python: E = np.outer(b, c) (ou b.dot(c) se os shapes estiverem corretos)]
Passo 5
(c) Calcular A E.
Dimensões: A é 2\times 4, E é 4\times 4 → produto é possível, resultado 2\times 4.
Observação útil (identidade prática): E=b c, então A E = A (b c) = (A b) c (associatividade da multiplicação de matrizes, quando dimensões permitem). Já calculamos A b=\begin{bmatrix}37\\\ 79\end{bmatrix}. Assim
A E = (A b) c = \begin{bmatrix}37\\[4pt]79\end{bmatrix} \begin{bmatrix}9 & 2 & 3 & 1\end{bmatrix} = \begin{bmatrix} 37\cdot 9 & 37\cdot 2 & 37\cdot 3 & 37\cdot 1\\[4pt] 79\cdot 9 & 79\cdot 2 & 79\cdot 3 & 79\cdot 1 \end{bmatrix}.
Calculando:
A E = \begin{bmatrix} 333 & 74 & 111 & 37\\[4pt] 711 & 158 & 237 & 79 \end{bmatrix}.
Script:
MATLAB: AE = A * E;
Python: AE = A.dot(E)]
Passo 6
(d) Calcular F = D A.
Dimensões: D é 2\times 2, A é 2\times 4 → resultado será 2\times 4.
Interpretação: D=\begin{bmatrix}0 & 1\\\\ 1 & 0\end{bmatrix} é a matriz que troca as linhas (permuta as linhas 1 e 2) quando multiplicamos D A. Então basta trocar as duas linhas de A.
F = DA = \begin{bmatrix}10 & 7 & 2 & 0\\[4pt]1 & 3 & 1 & 3\end{bmatrix}.
Script:
MATLAB: F = D * A;
Python: F = D.dot(A)]
Passo 7
(e) Calcular G = A D.
Verificação de dimensões: A é 2\times 4 e D é 2\times 2. Para multiplicar A D o número de colunas de A (que é 4) precisa ser igual ao número de linhas de D (que é 2). Aqui 4 \ne 2, portanto a multiplicação A D NÃO é definida — dará erro de dimensão em qualquer ambiente (MATLAB/NumPy).
Justificativa clara: requisito de compatibilidade de produto matricial não está satisfeito. Não existe G=A D com as dimensões dadas.
Script: tentar executar G = A * D; em MATLAB ou G = A.dot(D) em NumPy vai gerar erro de dimensão.
Passo 8
(f) Calcular F b.
Dimensões: F é 2\times 4 e b é 4\times 1 → compatível, resultado 2\times 1.
Lembrete: F foi obtido trocando as linhas de A, então F b deve ser o mesmo que trocar as entradas do vetor A b. Calculando:
Agora uma observação crucial: as colunas 1 e 4 de S são idênticas (ambas iguais a b). Se uma matriz tem duas colunas (ou linhas) iguais, suas colunas não são linearmente independentes → a matriz é singular → \det(S)=0 → S não tem inversa.
Conclusão: Não existe N=S^{-1} porque S é singular (duas colunas iguais). Qualquer tentativa de computar inv(S) em MATLAB/NumPy vai retornar erro ou aviso de matriz singular.
Script:
MATLAB:
S = [b, A’, b];
% invS = inv(S); % Isto dará erro: matrix is singular
Python:
S = np.hstack([b.reshape(-1,1), A.T, b.reshape(-1,1)])
Lembrete: M é uma matriz 4\times 4. Podemos usar eliminação para verificar quantas linhas/colunas independentes ela tem; na prática usamos função rank(M).
Na minha redução (mostrei passos mentais de eliminação gaussiana multiplicando por 10 para facilitar contas), encontrei que todas as 4 linhas são linearmente independentes → posto =4, isto é, posto completo (full rank). Portanto \operatorname{rank}(M)=4.
Script:
MATLAB: r = rank(M);
Python: r = np.linalg.matrix_rank(M)
Passo 11
(i) Determinante de M, \det(M).
Como já determinamos que M é de posto 4 (full rank), \det(M) é diferente de zero. Fiz a conta via eliminação (multiplicando antes por 10 para evitar trabalhar só com muitas casas decimais) e obtive para a matriz original M o valor aproximado
\det(M) \approx -0,0252.
Pequena justificativa numérica: ao eliminar obtive pivôs cujo produto (levando em conta o escalamento inicial por 10 em cada linha) leva a esse valor aproximado. O sinal negativo indica que a transformação linear representada por M inverte a orientação do espaço.
Script:
MATLAB: d = det(M);
Python: d = np.linalg.det(M)
Passo 12
(j) Autovalores e autovetores de M.
Definição rápida: autovalores \lambda e autovetores v satisfazem M v = \lambda v. Na prática, para uma matriz 4\times 4 preenchida com números reais e sem propriedades especiais, calculamos numericamente usando eig.
Exemplo de comandos:
MATLAB: [V,D] = eig(M); % D é diagonal com autovalores, V contém autovetores
Python: vals, vecs = np.linalg.eig(M)
Essas funções retornam autovalores (possivelmente complexos, mas para M real e não-simétrica alguns autovalores podem ser complexos). Como o cálculo numérico é feito por funções prontas, o script devolve os valores numéricos aproximados. Recomendo rodar uma vez o script para ver os valores numéricos exatos (com precisão) no seu ambiente — eis a chamada que eu colocaria no script:
Como o cálculo é numérico e longo para fazer à mão aqui, deixo a extração numérica para o script — o importante é que você saiba rodar eig e interpretar: cada coluna de V é um autovetor correspondente ao autovalor respectivo em D.
Passo 13
(k) Calcular M b.
Dimensões: M é 4\times 4, b é 4\times 1 → resultado 4\times 1. Faço o produto (cada entrada é produto escalar da linha correspondente de M por b).
M b = \begin{bmatrix}8,8\\[4pt]4,1\\[4pt]11,4\\[4pt]10,5\end{bmatrix}.
Script:
MATLAB: Mb = M * b;
Python: Mb = M.dot(b)]
Passo 14
(l) Calcular M^{-1}.
Como vimos, \det(M)\approx -0,0252 \ne 0, então M é invertível e M^{-1} existe. O cálculo da inversa é numérico e normalmente feito pela função inv (MATLAB) ou np.linalg.inv (NumPy).
Script:
MATLAB: Minv = inv(M);
Python: Minv = np.linalg.inv(M)
No corpo do script é suficiente executar essa linha e talvez formatar a saída; a inversa numérica terá entries com casas decimais e pode ser conferida diretamente pelo comando acima. (Como a inversa envolve várias operações numéricas, eu deixo a saída numérica para o computador, que faz isso sem erro e com precisão.)
Passo 15
(m) Calcular X = N M.
Lembrete: no item (g) tentamos calcular N=S^{-1}, mas S é singular (colunas repetidas) e portanto N NÃO existe. Consequentemente a multiplicação X = N M não pode ser feita — dá erro porque N não foi definida.
Justificativa: se N não existe, não se pode formar X.
Script:
A linha X = N * M; em MATLAB falhará porque N não existe.
Passo 16
(n) Calcular X^{2}.
Como X não existe (item anterior), X^{2} também não existe; portanto não há resultado — operação inválida.
Passo 17
(o) Construir P com p_{ij} = m_{ij}^{2} (cada elemento de P é o quadrado do correspondente de M).
Este é um cálculo elemento a elemento, simples: apenas elevamos cada entrada de M ao quadrado.
(g) Erro: a matriz formada por [\,b,\;A^{T},\;b\,] tem colunas 1 e 4 idênticas (singular), portanto sua inversa N NÃO existe
(h) \operatorname{rank}(M)=4
(i) \det(M)\approx -0,0252
(j) Autovalores e autovetores: calcular numericamente com a função eig (MATLAB: [V,D]=eig(M); Python: vals,vecs = np.linalg.eig(M)). (Resultados numéricos são obtidos diretamente ao executar o script com esse comando.)
(l) M^{-1} existe (pois \det(M)\neq 0); calcular numericamente com inv(M) (MATLAB) ou np.linalg.inv(M) (Python) no script para obter a matriz inversa numérica.
(m) Erro: X=N M não pode ser computada porque N não existe (veja item (g))
(n) Erro: X^{2} não pode ser computado pois X não existe