Matrizes e Operações

Matriz é simultaneamente três coisas: uma tabela de números, a representação de uma transformação linear e um objeto computacional cujo desempenho domina boa parte da computação científica moderna. Vale entender as três leituras.

Operações básicas

Soma e multiplicação por escalar são feitas elemento a elemento e exigem dimensões iguais.

Produto matricial $C = AB$ com $A \in \mathbb{R}^{m\times n}$ e $B \in \mathbb{R}^{n\times p}$:

$$c_{ij} = \sum_{k=1}^{n} a_{ik}b_{kj}$$

As dimensões internas precisam coincidir. O resultado é $m \times p$.

O produto não é comutativo: $AB \ne BA$ em geral, e frequentemente um dos dois nem está definido. Isso não é um detalhe técnico — reflete que compor transformações depende da ordem.

É associativo, porém, e isso tem consequência prática enorme. Calcular $A(BC)$ ou $(AB)C$ dá o mesmo resultado com custos muito diferentes: para $A$ de $10\times100$, $B$ de $100\times5$ e $C$ de $5\times50$, a ordem $(AB)C$ custa $5000 + 2500$ operações e $A(BC)$ custa $25000 + 50000$. O problema de escolher a melhor ordem é o clássico exercício de programação dinâmica da multiplicação de cadeia de matrizes.

Transposta e inversa

$$(A^T){ij} = a{ji}, \qquad (AB)^T = B^TA^T$$

Note a inversão da ordem — vale igual para a inversa: $(AB)^{-1} = B^{-1}A^{-1}$.

A inversa $A^{-1}$ satisfaz $AA^{-1} = A^{-1}A = I$. Existe apenas para matrizes quadradas com $\det(A) \ne 0$.

Nunca calcule a inversa para resolver um sistema. Para obter $x$ em $Ax = b$, use eliminação ou uma fatoração: é cerca de três vezes mais rápido e numericamente muito mais estável. numpy.linalg.solve(A, b) é a chamada certa; numpy.linalg.inv(A) @ b é o erro que aparece em código de quem aprendeu a fórmula antes do método.

Matrizes especiais

Tipo	Definição	Propriedade útil
Identidade $I$	$1$ na diagonal, $0$ fora	$AI = IA = A$
Diagonal	Zero fora da diagonal	Produto e inversa triviais
Triangular	Zeros de um lado	Sistema resolvido por substituição
Simétrica	$A = A^T$	Autovalores reais, autovetores ortogonais
Ortogonal	$Q^TQ = I$	$Q^{-1} = Q^T$; preserva norma
Esparsa	Maioria dos elementos nula	Armazenamento e produto especializados
Definida positiva	$x^TAx > 0$ para $x \ne 0$	Admite Cholesky

Matrizes ortogonais são especialmente valiosas em computação numérica: como preservam comprimentos e ângulos, não amplificam erro. É por isso que algoritmos estáveis (QR, SVD) são construídos sobre transformações ortogonais.

Matrizes esparsas são a regra em aplicações reais — grafos, elementos finitos, sistemas de recomendação. Armazená-las densamente é inviável: uma matriz $10^6 \times 10^6$ densa exigiria $8$ TB, enquanto a versão esparsa com 10 não nulos por linha cabe em cerca de $240$ MB.

Custo computacional

Operação	Custo ingênuo
Soma	$O(mn)$
Produto matriz-vetor	$O(mn)$
Produto matriz-matriz	$O(mnp)$
Inversa / determinante	$O(n^3)$
Resolver sistema	$O(n^3)$

O produto de duas matrizes $n \times n$ custa $O(n^3)$ pelo método direto. Strassen reduz para $O(n^{2{,}807})$ e algoritmos mais sofisticados chegam abaixo de $n^{2{,}372}$, mas com constantes tão grandes que não são usados na prática.

O que realmente importa em desempenho não é o expoente e sim a localidade de memória. Uma implementação ingênua com três laços tem péssimo aproveitamento de cache. Bibliotecas BLAS otimizadas trabalham por blocos que cabem no cache e chegam a ser duas ordens de grandeza mais rápidas que o código direto, com a mesma complexidade assintótica.

import numpy as np
A = np.random.rand(1000, 1000)
B = np.random.rand(1000, 1000)
C = A @ B          # chama BLAS: segundos → milissegundos

A lição prática: em álgebra linear numérica, nunca escreva o laço. Chame a biblioteca.

Traço e posto

O traço é a soma da diagonal, e satisfaz a propriedade cíclica $\operatorname{tr}(AB) = \operatorname{tr}(BA)$, muito usada em demonstrações de aprendizado de máquina. O traço também é a soma dos autovalores.

O posto é o número de linhas (ou colunas) linearmente independentes. Matrizes de posto baixo comprimem bem: se $A$ tem posto $r$, ela pode ser escrita como produto de uma $m\times r$ por uma $r\times n$, o que reduz o armazenamento de $mn$ para $r(m+n)$.

Exemplo trabalhado

$$A = \begin{pmatrix} 1 & 2 \ 3 & 4 \end{pmatrix}, \quad B = \begin{pmatrix} 0 & 1 \ 1 & 0 \end{pmatrix}$$

$$AB = \begin{pmatrix} 1\cdot0 + 2\cdot1 & 1\cdot1 + 2\cdot0 \ 3\cdot0 + 4\cdot1 & 3\cdot1 + 4\cdot0 \end{pmatrix} = \begin{pmatrix} 2 & 1 \ 4 & 3 \end{pmatrix}$$

$$BA = \begin{pmatrix} 3 & 4 \ 1 & 2 \end{pmatrix}$$

Confirmando que $AB \ne BA$: multiplicar por $B$ à direita troca colunas, à esquerda troca linhas.

Aplicações em computação

Redes neurais. Uma camada densa é $y = Wx + b$. O treinamento é dominado por produtos matriciais, e é exatamente isso que GPUs fazem bem.

Computação gráfica. Matrizes $4\times4$ em coordenadas homogêneas compõem toda a cadeia de transformações do pipeline.

Grafos. A potência $A^k$ da matriz de adjacência conta caminhos de comprimento $k$.

Simulação. Discretizar uma equação diferencial parcial produz um sistema linear esparso e enorme, resolvido por métodos iterativos.

Erros comuns

• Inverter para resolver sistema. Use solve, não inv.
• Confundir * com @. Em NumPy, * é produto elemento a elemento.
• Ignorar broadcasting e obter resultado de forma inesperada sem erro.
• Escrever laços aninhados em vez de chamar BLAS.
• Armazenar matriz esparsa densamente.
• Esquecer que o produto não comuta, sobretudo ao compor transformações gráficas.

Leituras recomendadas

• Strang, capítulos 1 a 3 — matrizes com ênfase em interpretação geométrica.
• Golub e Van Loan, Matrix Computations — a bíblia da álgebra linear numérica; referência para quem implementa.
• Documentação do NumPy e do SciPy sobre linalg — quando usar cada rotina e o que cada uma assume.
• Documentação do LAPACK — os nomes das rotinas e suas hipóteses; útil para entender mensagens de erro de bibliotecas de alto nível.

Gilbert Strang (2016). Introduction to Linear Algebra. Wellesley-Cambridge Press. ISBN 9780980232776. Gene H. Golub and Charles F. Van Loan (2013). Matrix Computations. Johns Hopkins University Press. DOI: 10.56021/9781421407944.

Referências

1. Gilbert Strang (2016). Introduction to Linear Algebra. Wellesley-Cambridge Press.
2. Gene H. Golub; Charles F. Van Loan (2013). Matrix Computations. Johns Hopkins University Press.