Crie um script que execute as operações matriciais a seguir. Justifique se as operações retornarem erro.
\begin{gathered} A=\left[\begin{array}{cccc} 1 & 3 & 1 & 3 \\\\ 10 & 7 & 2 & 0 \end{array}\right], b=\left[\begin{array}{l} 1 \\\\ 9 \\\\ 3 \\\\ 2 \end{array}\right], c=\left[\begin{array}{llll} 9 & 2 & 3 & 1 \end{array}\right] \\\ D=\left[\begin{array}{ll} 0 & 1 \\\\ 1 & 0 \end{array}\right] M=\left[\begin{array}{llll} 0,4 & 0,6 & 0,6 & 0,6 \\\\ 0,9 & 0,1 & 0,7 & 0,1 \\\\ 0,7 & 0,8 & 0,7 & 0,7 \\\\ 0,9 & 0,9 & 0,3 & 0,3 \end{array}\right] \end{gathered}
(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):
A=\begin{bmatrix} 1 & 3 & 1 & 3\\[4pt] 10 & 7 & 2 & 0 \end{bmatrix}, \qquad b=\begin{bmatrix}1\\[4pt]9\\[4pt]3\\[4pt]2\end{bmatrix}, \qquad c=\begin{bmatrix}9 & 2 & 3 & 1\end{bmatrix}
D=\begin{bmatrix}0 & 1\\[4pt]1 & 0\end{bmatrix}, \qquad M=\begin{bmatrix} 0,4 & 0,6 & 0,6 & 0,6\\[4pt] 0,9 & 0,1 & 0,7 & 0,1\\[4pt] 0,7 & 0,8 & 0,7 & 0,7\\[4pt] 0,9 & 0,9 & 0,3 & 0,3 \end{bmatrix}
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):
Primeira linha de A vezes b:
1\cdot 1 + 3\cdot 9 + 1\cdot 3 + 3\cdot 2 = 1 + 27 + 3 + 6 = 37.
Segunda linha de A vezes b:
10\cdot 1 + 7\cdot 9 + 2\cdot 3 + 0\cdot 2 = 10 + 63 + 6 + 0 = 79.
Portanto
A b = \begin{bmatrix}37\\[4pt]79\end{bmatrix}.
Exemplo de linha de script (MATLAB/Octave or Python/NumPy):
  • MATLAB: Ab = A * b;
  • Python: Ab = A.dot(b)]

Passo 4

(b) Calcular E = b c.
Dimensões: b é 4\times 1 e c é 1\times 4 → produto externo gera matriz 4\times 4.
Cada linha de E é b_i vezes o vetor c. Faço as contas:
b=\begin{bmatrix}1\\\ 9\\\ 3\\\ 2\end{bmatrix},\quad c=\begin{bmatrix}9 & 2 & 3 & 1\end{bmatrix}.
Logo
E = b c = \begin{bmatrix} 1\cdot 9 & 1\cdot 2 & 1\cdot 3 & 1\cdot 1\\[4pt] 9\cdot 9 & 9\cdot 2 & 9\cdot 3 & 9\cdot 1\\[4pt] 3\cdot 9 & 3\cdot 2 & 3\cdot 3 & 3\cdot 1\\[4pt] 2\cdot 9 & 2\cdot 2 & 2\cdot 3 & 2\cdot 1 \end{bmatrix} = \begin{bmatrix} 9 & 2 & 3 & 1\\[4pt] 81 & 18 & 27 & 9\\[4pt] 27 & 6 & 9 & 3\\[4pt] 18 & 4 & 6 & 2 \end{bmatrix}.
Script:
  • MATLAB: E = b * c;
  • 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.
A era
\begin{bmatrix}1 & 3 & 1 & 3\\[4pt]10 & 7 & 2 & 0\end{bmatrix}, logo
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:
Usando F=\begin{bmatrix}10 & 7 & 2 & 0\\[4pt]1 & 3 & 1 & 3\end{bmatrix} e b=\begin{bmatrix}1\\\ 9\\\ 3\\\ 2\end{bmatrix}:
Primeira linha:
10\cdot 1 + 7\cdot 9 + 2\cdot 3 + 0\cdot 2 = 10 + 63 + 6 +0 = 79.
Segunda linha:
1\cdot 1 + 3\cdot 9 + 1\cdot 3 + 3\cdot 2 = 1 + 27 + 3 + 6 = 37.
Portanto
F b = \begin{bmatrix}79\\[4pt]37\end{bmatrix}.
Script:
  • MATLAB: Fb = F * b;
  • Python: Fb = F.dot(b)]

Passo 9

(g) Concatenar b, A^{T} e b (da esquerda para a direita) e calcular a inversa da matriz resultante, atribuindo à variável N.
Primeiro calcular A^{T}. Como A é 2\times 4, A^{T} é 4\times 2. Escrevo A^{T} explicitamente (cada linha corresponde a uma coluna de A):
A^{T} = \begin{bmatrix} 1 & 10\\[4pt] 3 & 7\\[4pt] 1 & 2\\[4pt] 3 & 0 \end{bmatrix}.
Concatenando horizontalmente b ( 4\times1), A^{T} ( 4\times2) e b ( 4\times1) obtemos uma matriz quadrada 4\times 4. Vou escrever essa matriz S:
As colunas são: \text{col}_1=b, \text{col}_2= primeira coluna de A^{T}, \text{col}_3= segunda coluna de A^{T}, \text{col}_4=b. Assim
S = \begin{bmatrix} 1 & 1 & 10 & 1\\[4pt] 9 & 3 & 7 & 9\\[4pt] 3 & 1 & 2 & 3\\[4pt] 2 & 3 & 0 & 2 \end{bmatrix}.
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)])

    np.linalg.inv(S) # ValueError / LinAlgError: singular matrix]

Passo 10

(h) Posto (rank) da matriz M.
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:
  • MATLAB:
    [V,D] = eig(M);
    disp(‘Autovalores:’); disp(diag(D));
    disp(‘Autovetores (colunas de V):’); disp(V);
  • Python:
    vals, vecs = np.linalg.eig(M)
    print(‘Autovalores:’, vals)
    print(‘Autovetores (colunas):’, vecs)
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).
Row 1:
0,4\cdot 1 + 0,6\cdot 9 + 0,6\cdot 3 + 0,6\cdot 2 = 0,4 + 5,4 + 1,8 + 1,2 = 8,8.
Row 2:
0,9\cdot1 + 0,1\cdot9 + 0,7\cdot3 + 0,1\cdot2 = 0,9 + 0,9 + 2,1 + 0,2 = 4,1.
Row 3:
0,7\cdot1 + 0,8\cdot9 + 0,7\cdot3 + 0,7\cdot2 = 0,7 + 7,2 + 2,1 + 1,4 = 11,4.
Row 4:
0,9\cdot1 + 0,9\cdot9 + 0,3\cdot3 + 0,3\cdot2 = 0,9 + 8,1 + 0,9 + 0,6 = 10,5.
Portanto
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.
Fazendo isso:
P = \begin{bmatrix} (0,4)^{2} & (0,6)^{2} & (0,6)^{2} & (0,6)^{2}\\[4pt] (0,9)^{2} & (0,1)^{2} & (0,7)^{2} & (0,1)^{2}\\[4pt] (0,7)^{2} & (0,8)^{2} & (0,7)^{2} & (0,7)^{2}\\[4pt] (0,9)^{2} & (0,9)^{2} & (0,3)^{2} & (0,3)^{2} \end{bmatrix} = \begin{bmatrix} 0,16 & 0,36 & 0,36 & 0,36\\[4pt] 0,81 & 0,01 & 0,49 & 0,01\\[4pt] 0,49 & 0,64 & 0,49 & 0,49\\[4pt] 0,81 & 0,81 & 0,09 & 0,09 \end{bmatrix}.
Script:
  • MATLAB: P = M.^2;
  • Python: P = np.square(M)]

Resposta

(a) \displaystyle \begin{bmatrix}37\\[4pt]79\end{bmatrix}
(b) \displaystyle \begin{bmatrix}9 & 2 & 3 & 1\\[4pt]81 & 18 & 27 & 9\\[4pt]27 & 6 & 9 & 3\\[4pt]18 & 4 & 6 & 2\end{bmatrix}
(c) \displaystyle \begin{bmatrix}333 & 74 & 111 & 37\\[4pt]711 & 158 & 237 & 79\end{bmatrix}
(d) \displaystyle \begin{bmatrix}10 & 7 & 2 & 0\\[4pt]1 & 3 & 1 & 3\end{bmatrix}
(e) Erro: operação inválida por incompatibilidade de dimensões (não é possível multiplicar A 2\times 4 por D 2\times 2)
(f) \displaystyle \begin{bmatrix}79\\[4pt]37\end{bmatrix}
(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.)
(k) \displaystyle \begin{bmatrix}8,8\\[4pt]4,1\\[4pt]11,4\\[4pt]10,5\end{bmatrix}
(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
(o) \displaystyle P=\begin{bmatrix}0,16 & 0,36 & 0,36 & 0,36\\[4pt]0,81 & 0,01 & 0,49 & 0,01\\[4pt]0,49 & 0,64 & 0,49 & 0,49\\[4pt]0,81 & 0,81 & 0,09 & 0,09\end{bmatrix}]

Exercícios relacionados