Guia de Notação

2026-07-26T00:00:00+00:00

Guia de Notação</h1>
Referência rápida dos símbolos usados neste guia. Notação é convenção, e convenções variam entre áreas — quando houver ambiguidade, ela é apontada.

Conjuntos</h2>

Símbolo</th> Significado</th></tr></thead>

$\in$, $\notin$</td> Pertence, não pertence</td></tr>

$\subseteq$, $\subsetneq$</td> Subconjunto, subconjunto próprio</td></tr>

$\cup$, $\cap$</td> União, interseção</td></tr>

$\setminus$</td> Diferença</td></tr>

$\overline{A}$</td> Complemento</td></tr>

$\emptyset$</td> Conjunto vazio</td></tr>

$\mathcal{P}(A)$</td> Conjunto potência</td></tr>

$\lvert A \rvert$</td> Cardinalidade</td></tr>

$A\times B$</td>

Produto cartesiano</td></tr> </tbody></table>

Conjuntos numéricos</h2>

Símbolo</th> Conjunto</th></tr></thead>

$\mathbb{N}$</td> Naturais</td></tr>

$\mathbb{Z}$</td> Inteiros</td></tr>

$\mathbb{Q}$</td> Racionais</td></tr>

$\mathbb{R}$</td> Reais</td></tr>

$\mathbb{C}$</td> Complexos</td></tr>

$\mathbb{F}_q$, $\mathbb{Z}_n$</td>

Corpo finito, inteiros módulo $n$</td></tr> </tbody></table>

Atenção: alguns autores incluem o zero em $\mathbb{N}$ e outros não. Neste guia, o contexto deixa claro.

Lógica</h2>

Símbolo</th> Significado</th></tr></thead>

$\neg$</td> Negação</td></tr>

$\wedge$, $\vee$</td> E, ou</td></tr>

$\to$, $\leftrightarrow$</td> Implica, se e somente se</td></tr>

$\forall$, $\exists$</td> Para todo, existe</td></tr>

$\equiv$</td> Equivalente</td></tr>

$\blacksquare$</td>

Fim de demonstração</td></tr> </tbody></table>

Somatórios e produtos</h2>
$$\sum_{i=1}^{n}a_i = a_1 + \cdots + a_n, \qquad \prod_{i=1}^{n}a_i = a_1\cdots a_n$$
Somatório sobre conjunto vazio é $0$; produto sobre conjunto vazio é $1$. Essa convenção não é arbitrária — é o elemento neutro de cada operação, e é o que faz fórmulas recursivas funcionarem no caso base.

Funções e arredondamento</h2>

Símbolo</th> Significado</th></tr></thead>

$f: A\to B$</td> Função de $A$ em $B$</td></tr>

$f\circ g$</td> Composição</td></tr>

$f^{-1}$</td> Inversa</td></tr>

$\lfloor x\rfloor$, $\lceil x\rceil$</td> Piso, teto</td></tr>

$n!$</td> Fatorial</td></tr>

$\binom{n}{k}$</td> Coeficiente binomial</td></tr>

$\gcd$, $\operatorname{lcm}$</td> MDC, MMC</td></tr>

$a \bmod n$</td> Resto</td></tr>

$a \equiv b \pmod n$</td>

Congruência</td></tr> </tbody></table>

Álgebra linear</h2>

Símbolo</th> Significado</th></tr></thead>

$A^T$, $A^{-1}$, $A^+$</td> Transposta, inversa, pseudoinversa</td></tr>

$\det(A)$, $\operatorname{tr}(A)$</td> Determinante, traço</td></tr>

$\langle u,v\rangle$, $u^Tv$</td> Produto interno</td></tr>

$\lVert x\rVert_p$</td> Norma $p$</td></tr>

$\kappa(A)$</td> Número de condição</td></tr>

$\lambda$, $\sigma$</td> Autovalor, valor singular</td></tr>

$I$</td>

Identidade</td></tr> </tbody></table>

Vetores são colunas por padrão. Algumas bibliotecas gráficas usam a convenção de linha, o que inverte a ordem dos produtos — verifique sempre.

Probabilidade</h2>

Símbolo</th> Significado</th></tr></thead>

$P(A)$</td> Probabilidade</td></tr>

$P(A\mid B)$</td> Probabilidade condicional</td></tr>

$E[X]$</td> Esperança</td></tr>

$\operatorname{Var}(X)$, $\sigma^2$</td> Variância</td></tr>

$\operatorname{Cov}(X,Y)$</td> Covariância</td></tr>

$X\sim\mathcal{D}$</td> $X$ segue a distribuição $\mathcal{D}$</td></tr>

$\mathcal{N}(\mu,\sigma^2)$</td>

Normal</td></tr> </tbody></table>

Assintótica</h2>

Símbolo</th> Significado</th></tr></thead>

$O(g)$</td> Cresce no máximo como $g$</td></tr>

$\Omega(g)$</td> Cresce pelo menos como $g$</td></tr>

$\Theta(g)$</td> Mesma ordem</td></tr>

$o(g)$, $\omega(g)$</td> Estritamente menor, estritamente maior</td></tr>

$\sim$</td>

Assintoticamente igual</td></tr> </tbody></table>

$\log n$ sem base indicada significa que a base é irrelevante — ela muda apenas a constante.

Convenções deste guia</h2>

Trechos de código são em Python quando servem para ilustrar, e não pretendem ser implementações de produção.</li> </ul>

Referências</h2>

Michael Sipser (2012). Introduction to the Theory of Computation. Cengage Learning.</li> </ol>

Roteiros de Estudo

2026-07-26T00:00:00+00:00

Roteiros de Estudo</h1>
O guia não precisa ser lido em ordem. Abaixo, percursos por objetivo — cada um levando de umas poucas horas a algumas semanas, conforme a profundidade desejada.
Base mínima para computação</h2>
Se você vai fazer um percurso, faça este. Ele cobre o que aparece em praticamente qualquer contexto técnico.

Lógica proposicional</a></li>
Teoria dos conjuntos</a></li>
Funções</a></li>
Indução matemática</a></li>
Análise assintótica</a></li>
Grafos: fundamentos</a></li>
Ponto flutuante</a></li> </ol>
O último item costuma surpreender quem espera uma lista só de teoria. Ele está aqui porque é a fonte mais comum de defeitos silenciosos em código.
Preparação para entrevistas técnicas</h2>
Foco no que efetivamente é cobrado.

Análise assintótica</a></li>
Recorrências</a></li>
Combinatória</a></li>
Grafos: fundamentos</a></li>
Árvores</a></li>
Caminhos mínimos</a></li>
Princípio da casa dos pombos</a></li>
Espaço amostral e eventos</a></li> </ol>
Aprendizado de máquina</h2>
O percurso mais longo, e o que exige mais álgebra linear.

Espaços vetoriais</a></li>
Matrizes e operações</a></li>
Produto interno e normas</a></li>
Autovalores e autovetores</a></li>
SVD</a></li>
Derivadas</a></li>
Variáveis aleatórias e esperança</a></li>
Distribuições</a></li>
Probabilidade condicional e Bayes</a></li>
Concentração e algoritmos aleatorizados</a></li> </ol>
Criptografia e segurança</h2>

Divisibilidade e algoritmo de Euclides</a></li>
Aritmética modular</a></li>
Teorema chinês do resto</a></li>
Fermat, Euler e testes de primalidade</a></li>
RSA</a></li>
Princípio da casa dos pombos</a> — para o ataque do aniversário</li>
Classes P, NP e reduções</a></li> </ol>
Computação gráfica</h2>

Espaços vetoriais</a></li>
Matrizes e operações</a></li>
Transformações lineares</a></li>
Determinante</a></li>
Produto interno e normas</a></li>
Interpolação e integração numérica</a></li>
Ponto flutuante</a></li> </ol>
Computação científica</h2>

Ponto flutuante</a></li>
Erro e condicionamento</a></li>
Sistemas lineares</a></li>
Decomposições LU e Cholesky</a></li>
Ortogonalidade e fatoração QR</a></li>
Raízes e método de Newton</a></li>
Séries de Taylor</a></li>
Interpolação e integração numérica</a></li> </ol>
Compiladores e linguagens</h2>

Lógica proposicional</a></li>
Relações</a></li>
Autômatos e linguagens formais</a></li>
Máquina de Turing e decidibilidade</a></li>
Coloração de grafos</a> — alocação de registradores</li>
Árvores</a></li> </ol>
Como estudar</h2>
Três recomendações que valem para qualquer percurso.
Faça as contas à mão pelo menos uma vez. Cada página tem um exemplo trabalhado. Refazê-lo no papel, sem olhar, é o que separa reconhecer de saber.
Implemente o algoritmo. Os trechos de código do guia são curtos de propósito. Digitá-los e rodá-los com entradas próprias revela detalhes que a leitura esconde.
Volte depois. Conceitos de matemática raramente são absorvidos numa passada. Reler um mês depois, tendo usado a ideia no meio-tempo, é mais produtivo que reler no dia seguinte — é a prática de recuperação espaçada, e ela tem base experimental sólida.
Referências</h2>

Kenneth H. Rosen (2019). Discrete Mathematics and Its Applications. McGraw-Hill.</li>
Thomas H. Cormen; Charles E. Leiserson; Ronald L. Rivest; Clifford Stein (2009). Introduction to Algorithms. MIT Press.</li>
Michael Sipser (2012). Introduction to the Theory of Computation. Cengage Learning.</li> </ol>

Autovalores e Autovetores

2026-07-26T00:00:00+00:00

Autovalores e Autovetores</h1>
Autovalores respondem a uma pergunta específica: existem direções que a transformação apenas estica ou encolhe, sem girar? Essas direções revelam a estrutura essencial da matriz e são a base do PCA, do PageRank e da análise de estabilidade.
Definição</h2>
Um vetor não nulo $v$ é autovetor de $A$ com autovalor $\lambda$ quando
$$Av = \lambda v$$
Aplicar $A$ a $v$ não muda sua direção, só sua escala.
Da equação segue $(A - \lambda I)v = 0$ com $v \ne 0$, o que exige $A - \lambda I$ singular:
$$\det(A - \lambda I) = 0$$
Esse é o polinômio característico, de grau $n$. Sobre os complexos ele tem exatamente $n$ raízes contando multiplicidade — mas uma matriz real pode ter autovalores complexos, como toda matriz de rotação.
Fatos essenciais</h2>
$$\sum_i \lambda_i = \operatorname{tr}(A), \qquad \prod_i \lambda_i = \det(A)$$
São duas verificações baratas e muito úteis para conferir um cálculo.
Outros fatos que vale ter na ponta da língua:

Matriz triangular: os autovalores são a diagonal.</li>
Matriz simétrica real: autovalores reais, autovetores ortogonais.</li>
Matriz ortogonal: autovalores de módulo 1.</li>
$A^k$ tem autovalores $\lambda_i^k$, com os mesmos autovetores.</li>
$A$ é singular se e somente se $0$ é autovalor.</li> </ul>
Diagonalização</h2>
Se $A$ tem $n$ autovetores linearmente independentes, então
$$A = PDP^{-1}$$
com $P$ a matriz dos autovetores em colunas e $D$ diagonal com os autovalores.
O ganho é computacional e conceitual:
$$A^k = PD^kP^{-1}$$
Elevar uma matriz diagonal à potência $k$ é elevar cada entrada. Isso transforma um cálculo caro num trivial, e é o que permite analisar o comportamento de longo prazo de sistemas iterativos: o autovalor de maior módulo domina.
Nem toda matriz é diagonalizável. Matrizes defeituosas — como $\begin{pmatrix}1&1\0&1\end{pmatrix}$, que tem autovalor $1$ com multiplicidade 2 mas só um autovetor independente — exigem a forma de Jordan.
Teorema espectral</h2>
Para $A$ simétrica real:
$$A = Q\Lambda Q^T$$
com $Q$ ortogonal e $\Lambda$ diagonal real.
Este é o resultado mais útil da área. Ele garante que matrizes simétricas são sempre diagonalizáveis, com base ortonormal de autovetores e autovalores reais. Como $Q^{-1} = Q^T$, não há inversão a calcular e o cálculo é numericamente estável.
Matrizes simétricas aparecem em toda parte — matrizes de covariância, hessianas, laplacianos de grafos, matrizes de Gram — e é o teorema espectral que torna esses objetos tratáveis.
Uma matriz simétrica é definida positiva exatamente quando todos os autovalores são positivos.
Cálculo na prática</h2>
Não use o polinômio característico. Os métodos reais:
Método da potência. Itera $v_{k+1} = Av_k / |Av_k|$ e converge para o autovetor dominante. Simples, e é a ideia por trás do PageRank.
Iteração QR. Fatora repetidamente $A_k = Q_kR_k$ e faz $A_{k+1} = R_kQ_k$. Converge para forma triangular com os autovalores na diagonal. É o algoritmo padrão.
Lanczos e Arnoldi. Para matrizes esparsas grandes quando se quer apenas alguns autovalores.
import numpy as np vals, vecs = np.linalg.eigh(A) # simétrica: mais rápido e estável vals, vecs = np.linalg.eig(A) # geral: pode devolver complexos</code></pre> Use eigh</code> sempre que a matriz for simétrica — a diferença de desempenho e de estabilidade é significativa. Exemplo trabalhado</h2> $$A = \begin{pmatrix} 2 & 1 \ 1 & 2 \end{pmatrix}$$ $$\det(A - \lambda I) = (2-\lambda)^2 - 1 = \lambda^2 - 4\lambda + 3 = (\lambda-1)(\lambda-3)$$ Autovalores $\lambda_1 = 1$, $\lambda_2 = 3$. Conferindo: a soma é $4 = \operatorname{tr}(A)$ e o produto é $3 = \det(A)$. Para $\lambda = 3$: $(A - 3I)v = 0$ dá $-v_1 + v_2 = 0$, logo $v = (1,1)$. Para $\lambda = 1$: $v = (1,-1)$. Os autovetores são ortogonais, como o teorema espectral prevê para matriz simétrica. Aplicações em computação</h2> PCA. Os autovetores da matriz de covariância são as direções principais, e os autovalores medem a variância em cada direção. Manter os maiores é reduzir dimensionalidade preservando o máximo de informação. PageRank. A pontuação de páginas é o autovetor dominante da matriz de transição da web. O método da potência converge à distribuição estacionária, e a taxa de convergência é dada pela razão entre o segundo e o primeiro autovalor. Agrupamento espectral. Os autovetores do laplaciano do grafo revelam estrutura de comunidades. O número de autovalores nulos conta os componentes conexos. Estabilidade. Num sistema dinâmico $x_{k+1} = Ax_k$, a trajetória converge se e somente se todos os autovalores têm módulo menor que 1. O mesmo critério governa a estabilidade de esquemas numéricos. Vibrações e gráficos. Modos naturais de deformação de uma malha são autovetores do operador laplaciano discreto. Erros comuns</h2> Calcular autovalores por raízes do polinômio característico. Numericamente instável.</li> Usar eig</code> em matriz simétrica em vez de eigh</code>.</li> Supor que toda matriz é diagonalizável.</li> Esperar autovalores reais de matriz não simétrica. Rotações têm autovalores complexos.</li> Ignorar a normalização. Autovetores são definidos a menos de escala, e o sinal devolvido pela biblioteca é arbitrário.</li> </ul> Leituras recomendadas</h2> Strang, capítulo 6 — autovalores com muitas aplicações trabalhadas.</li> Axler, capítulos 5 e 7 — a abordagem sem determinantes, que esclarece por que o teorema espectral é verdadeiro.</li> Trefethen e Bau, lições 24 a 30 — algoritmos de autovalores e por que a iteração QR funciona.</li> Artigo original do PageRank (Page e Brin) — o método da potência aplicado em escala.</li> </ul> Gilbert Strang (2016). Introduction to Linear Algebra. Wellesley-Cambridge Press. ISBN 9780980232776</a>. Sheldon Axler (2015). Linear Algebra Done Right. Springer. DOI: 10.1007/978-3-319-11080-6</a>. Lloyd N. Trefethen and David Bau III (1997). Numerical Linear Algebra. SIAM. DOI: 10.1137/1.9780898719574</a>. Referências</h2> Gilbert Strang (2016). Introduction to Linear Algebra. Wellesley-Cambridge Press.</li> Sheldon Axler (2015). Linear Algebra Done Right. Springer.</li> Lloyd N. Trefethen; David Bau III (1997). Numerical Linear Algebra. SIAM.</li> </ol>
Decomposições LU e Cholesky 2026-07-26T00:00:00+00:00 Decomposições LU e Cholesky</h1> Fatorar uma matriz é reescrevê-la como produto de fatores mais simples. A ideia central é econômica: fatore uma vez, resolva muitas. Se você precisa resolver $Ax = b$ para vários $b$ diferentes com a mesma $A$, a fatoração transforma um custo $O(n^3)$ por sistema em $O(n^3)$ uma vez e $O(n^2)$ por sistema. Fatoração LU</h2> $$A = LU$$ com $L$ triangular inferior de diagonal unitária e $U$ triangular superior. É a eliminação gaussiana registrada em forma matricial: $U$ é o resultado da eliminação e $L$ guarda os multiplicadores usados. Resolver $Ax = b$ vira dois sistemas triangulares: $Ly = b$ por substituição progressiva — $O(n^2)$.</li> $Ux = y$ por substituição regressiva — $O(n^2)$.</li> </ol> Custo da fatoração: $\frac{2}{3}n^3$. Pivoteamento: PA = LU</h2> A fatoração pura falha quando surge pivô nulo e fica imprecisa com pivô pequeno. Na prática usa-se pivoteamento parcial: $$PA = LU$$ com $P$ uma matriz de permutação. Isso garante que todos os multiplicadores tenham módulo $\le 1$. import numpy as np from scipy.linalg import lu_factor, lu_solve lu, piv = lu_factor(A) # fatora uma vez: O(n³) x1 = lu_solve((lu, piv), b1) # cada resolução: O(n²) x2 = lu_solve((lu, piv), b2)</code></pre> Este padrão — fatorar fora do laço, resolver dentro — é a otimização mais importante de qualquer código que resolve sistemas repetidamente, e é frequentemente esquecida. Cholesky</h2> Para $A$ simétrica e definida positiva: $$A = LL^T$$ com $L$ triangular inferior de diagonal positiva. Vantagens sobre a LU: Metade do custo: $\frac{1}{3}n^3$.</li> Metade da memória: só um fator.</li> Sem pivoteamento: é incondicionalmente estável para matrizes definidas positivas.</li> </ul> import numpy as np L = np.linalg.cholesky(A) # falha se A não for definida positiva</code></pre> O fato de a fatoração falhar quando a matriz não é definida positiva é uma característica útil, não um defeito: é o teste mais barato dessa propriedade. Métodos de otimização usam exatamente isso para detectar que a hessiana deixou de ser definida positiva e que o passo de Newton precisa ser corrigido. Matrizes simétricas definidas positivas são comuns: matrizes de covariância, matrizes de Gram $A^TA$, hessianas em pontos de mínimo, laplacianos com condição de contorno. Comparação</h2> Fatoração</th> Requisito</th> Custo</th> Uso</th></tr></thead> LU</td> Quadrada</td> $\frac23 n^3$</td> Sistemas gerais</td></tr> Cholesky</td> Simétrica definida positiva</td> $\frac13 n^3$</td> Covariância, mínimos quadrados</td></tr> QR</td> $m \ge n$</td> $\frac43 n^3$</td> Mínimos quadrados, estabilidade</td></tr> SVD</td> Qualquer</td> $\sim 10n^3$</td> Posto, pseudoinversa, mal condicionado</td></tr> </tbody></table> A ordem de preferência prática é: use a fatoração mais barata cujas hipóteses a sua matriz satisfaça, exceto quando o condicionamento exigir a mais robusta. Determinante e log-determinante</h2> Da fatoração sai o determinante de graça: $$\det(A) = \det(P)^{-1}\prod_i u_{ii}, \qquad \det(A) = \prod_i \ell_{ii}^2 ;\text{(Cholesky)}$$ Para evitar estouro, calcula-se o logaritmo: L = np.linalg.cholesky(Sigma) log_det = 2 * np.sum(np.log(np.diag(L)))</code></pre> Essa expressão aparece diretamente na verossimilhança da distribuição normal multivariada e em processos gaussianos, onde $\Sigma$ pode ter milhares de dimensões. Amostragem de normal multivariada</h2> Uma aplicação elegante de Cholesky: para amostrar $x \sim \mathcal{N}(\mu, \Sigma)$, basta $$x = \mu + Lz, \qquad z \sim \mathcal{N}(0, I)$$ pois $\operatorname{Cov}(Lz) = L,I,L^T = LL^T = \Sigma$. Uma fatoração resolve o problema de gerar amostras correlacionadas a partir de ruído independente. Matrizes esparsas</h2> Para sistemas esparsos grandes, a fatoração sofre preenchimento: zeros viram não zeros durante a eliminação, e o fator pode ser muito mais denso que a matriz original. Duas respostas: Reordenação (mínimo grau aproximado, dissecção aninhada) para reduzir o preenchimento antes de fatorar.</li> Métodos iterativos (gradientes conjugados, GMRES), que nunca formam o fator e só precisam do produto matriz-vetor.</li> </ul> Para matrizes muito grandes — milhões de incógnitas em simulação — os métodos iterativos são a única opção viável. Exemplo trabalhado</h2> $$A = \begin{pmatrix} 4 & 2 \ 2 & 3 \end{pmatrix}$$ Simétrica; testemos Cholesky. Buscamos $L = \begin{pmatrix} \ell_{11} & 0 \ \ell_{21} & \ell_{22}\end{pmatrix}$: $\ell_{11}^2 = 4 \Rightarrow \ell_{11} = 2$</li> $\ell_{21}\ell_{11} = 2 \Rightarrow \ell_{21} = 1$</li> $\ell_{21}^2 + \ell_{22}^2 = 3 \Rightarrow \ell_{22} = \sqrt2$</li> </ul> Como todas as raízes existem e são reais, $A$ é definida positiva. E $\det(A) = (2 \cdot \sqrt2)^2 = 8$, que confere com $4\cdot3 - 2\cdot2 = 8$. Erros comuns</h2> Refatorar dentro do laço. O erro de desempenho mais frequente nesta área.</li> Cholesky em matriz não definida positiva. Vai falhar — trate a exceção em vez de ignorá-la.</li> Ignorar o pivoteamento ao implementar LU manualmente.</li> Formar o produto $A^TA$ só para poder usar Cholesky, elevando o condicionamento ao quadrado; prefira QR.</li> Fatorar matriz esparsa sem reordenar, causando explosão de memória.</li> </ul> Leituras recomendadas</h2> Golub e Van Loan, capítulos 3 e 4 — LU e Cholesky em detalhe, incluindo variantes por blocos.</li> Trefethen e Bau, lições 20 a 23 — estabilidade da eliminação gaussiana e por que o pivoteamento parcial funciona na prática.</li> Davis, Direct Methods for Sparse Linear Systems — a referência sobre fatoração esparsa e reordenação.</li> Documentação do SuiteSparse e do scipy.sparse.linalg</code> — as ferramentas de produção.</li> </ul> Gene H. Golub and Charles F. Van Loan (2013). Matrix Computations. Johns Hopkins University Press. DOI: 10.56021/9781421407944</a>. Lloyd N. Trefethen and David Bau III (1997). Numerical Linear Algebra. SIAM. DOI: 10.1137/1.9780898719574</a>. Nicholas J. Higham (2002). Accuracy and Stability of Numerical Algorithms. SIAM. DOI: 10.1137/1.9780898718027</a>. Referências</h2> Gene H. Golub; Charles F. Van Loan (2013). Matrix Computations. Johns Hopkins University Press.</li> Lloyd N. Trefethen; David Bau III (1997). Numerical Linear Algebra. SIAM.</li> Nicholas J. Higham (2002). Accuracy and Stability of Numerical Algorithms. SIAM.</li> </ol> Determinante 2026-07-26T00:00:00+00:00 Determinante</h1> O determinante é um número associado a uma matriz quadrada que responde a uma pergunta geométrica: quanto a transformação multiplica volumes, e ela inverte a orientação? Definição e cálculo</h2> Para $2\times2$ e $3\times3$: $$\det\begin{pmatrix} a & b \ c & d \end{pmatrix} = ad - bc$$ A definição geral é a expansão de Laplace, recursiva em menores. Ela é inutilizável computacionalmente: custa $O(n!)$ operações. Para $n = 20$ seriam mais de $10^{18}$ operações. O método correto é fatorar. Como o determinante de uma triangular é o produto da diagonal, e a eliminação gaussiana só troca o sinal (nas trocas de linha) ou preserva o valor (nas combinações), basta: import numpy as np sinal, logdet = np.linalg.slogdet(A) # estável mesmo para n grande det = sinal * np.exp(logdet)</code></pre> Custo $O(n^3)$. A variante slogdet</code> existe porque determinantes de matrizes grandes estouram a faixa do ponto flutuante com facilidade — o determinante de uma matriz $100\times100$ com entradas da ordem de 10 já ultrapassa $10^{100}$. Propriedades</h2> Propriedade</th> Enunciado</th></tr></thead> Produto</td> $\det(AB) = \det(A)\det(B)$</td></tr> Transposta</td> $\det(A^T) = \det(A)$</td></tr> Inversa</td> $\det(A^{-1}) = 1/\det(A)$</td></tr> Escalar</td> $\det(cA) = c^n \det(A)$</td></tr> Triangular</td> Produto da diagonal</td></tr> Troca de linhas</td> Inverte o sinal</td></tr> Linha nula ou repetida</td> $\det = 0$</td></tr> </tbody></table> A propriedade do produto é a mais reveladora: compor transformações multiplica os fatores de volume, exatamente como se espera geometricamente. Note que $\det(A+B) \ne \det(A) + \det(B)$ — o determinante não é linear na matriz, apesar de ser linear em cada linha separadamente. Interpretação geométrica</h2> $|\det(A)|$ é o volume da imagem do cubo unitário. O sinal indica orientação: negativo significa que a transformação reflete. Isso dá utilidade direta em geometria computacional. Para três pontos no plano, o sinal de $$\det\begin{pmatrix} x_2-x_1 & y_2-y_1 \ x_3-x_1 & y_3-y_1 \end{pmatrix}$$ diz se o terceiro está à esquerda ou à direita da reta pelos dois primeiros. Esse teste de orientação é a primitiva sobre a qual se constroem fecho convexo, triangulação e teste de interseção de segmentos. O módulo do mesmo determinante é o dobro da área do triângulo. Determinante e singularidade</h2> $$\det(A) = 0 \iff A \text{ não é inversível} \iff \text{as colunas são dependentes}$$ Geometricamente: a transformação achatou o espaço, colapsando pelo menos uma dimensão. Cuidado numérico: comparar o determinante com zero é um teste ruim de singularidade. Ele depende da escala — multiplicar a matriz por $0{,}1$ multiplica o determinante por $10^{-n}$, sem mudar nada de essencial. O indicador correto é o número de condição ou o menor valor singular. Regra de Cramer: por que não usar</h2> A regra dá a solução de $Ax=b$ como razão de determinantes: $$x_i = \frac{\det(A_i)}{\det(A)}$$ com $A_i$ a matriz com a $i$-ésima coluna substituída por $b$. É elegante e teoricamente útil, mas na prática é ruim em tudo: exige $n+1$ determinantes, é numericamente instável e mais lenta que a eliminação. Use-a para provar teoremas, nunca para calcular. Autovalores e polinômio característico</h2> $$p(\lambda) = \det(A - \lambda I)$$ As raízes são os autovalores, e daí decorre que o determinante é o produto dos autovalores (assim como o traço é a soma). Ainda assim, calcular autovalores pelo polinômio característico é numericamente desastroso: as raízes de um polinômio são extremamente sensíveis aos coeficientes. Algoritmos reais usam iteração QR. Exemplo trabalhado</h2> $$A = \begin{pmatrix} 2 & 1 \ 4 & 3 \end{pmatrix}, \quad \det(A) = 2\cdot3 - 1\cdot4 = 2$$ A matriz dobra áreas e preserva orientação. Como $\det \ne 0$, é inversível: $$A^{-1} = \frac{1}{2}\begin{pmatrix} 3 & -1 \ -4 & 2 \end{pmatrix}$$ E de fato $\det(A^{-1}) = \frac{1}{2}$, o inverso do determinante original. Aplicações em computação</h2> Geometria computacional. Testes de orientação, verificação de pontos dentro de circunferência (predicado incircle) na triangulação de Delaunay. Computação gráfica. O jacobiano de uma parametrização usa determinante; a mudança de variáveis em integração também. Detecção de degeneração. Em simulação de malhas, um elemento com determinante do jacobiano negativo está invertido — defeito que precisa ser detectado. Probabilidade. A densidade da distribuição normal multivariada contém $\det(\Sigma)$; na prática usa-se o log-determinante via Cholesky. Erros comuns</h2> Expansão de Laplace para $n$ grande. Fatorial é intratável.</li> Testar singularidade comparando com zero. Use condicionamento.</li> Usar Cramer para resolver sistemas.</li> Supor linearidade na soma de matrizes.</li> Estouro numérico em determinantes de matrizes grandes; use log-determinante.</li> </ul> Leituras recomendadas</h2> Strang, capítulo 5 — determinantes com ênfase geométrica.</li> Axler — argumenta convincentemente que determinantes devem vir depois de autovalores, não antes.</li> Trefethen e Bau, lição 1 — por que o determinante importa pouco em álgebra linear numérica.</li> Shewchuk, artigos sobre predicados geométricos robustos — como calcular sinais de determinantes com exatidão garantida.</li> </ul> Gilbert Strang (2016). Introduction to Linear Algebra. Wellesley-Cambridge Press. ISBN 9780980232776</a>. Sheldon Axler (2015). Linear Algebra Done Right. Springer. DOI: 10.1007/978-3-319-11080-6</a>. Referências</h2> Gilbert Strang (2016). Introduction to Linear Algebra. Wellesley-Cambridge Press.</li> Sheldon Axler (2015). Linear Algebra Done Right. Springer.</li> </ol> Espaços Vetoriais 2026-07-26T00:00:00+00:00 Espaços Vetoriais</h1> Vetor não é "uma seta" nem "uma lista de números" — essas são representações. Um espaço vetorial é qualquer conjunto em que faça sentido somar elementos e multiplicá-los por escalares, respeitando as regras usuais. Essa abstração é o que faz a álgebra linear render tanto: o mesmo teorema vale para vetores geométricos, polinômios, funções, sinais e imagens. Definição</h2> Um espaço vetorial sobre um corpo $\mathbb{F}$ (em geral $\mathbb{R}$ ou $\mathbb{C}$) é um conjunto $V$ com duas operações satisfazendo oito axiomas: associatividade e comutatividade da soma, existência de vetor nulo e de opostos, e compatibilidade da multiplicação escalar com a distributividade. Exemplos que valem ter em mente: Espaço</th> Elementos</th></tr></thead> $\mathbb{R}^n$</td> $n$-uplas de reais</td></tr> $\mathbb{R}^{m \times n}$</td> Matrizes</td></tr> $P_n$</td> Polinômios de grau $\le n$</td></tr> $C[a,b]$</td> Funções contínuas num intervalo</td></tr> $\mathbb{F}_2^n$</td> Vetores de bits, com soma XOR</td></tr> </tbody></table> O último é particularmente relevante em computação: códigos corretores de erro e criptografia operam em espaços vetoriais sobre corpos finitos, onde a soma é o ou-exclusivo. Combinação linear e geração</h2> Uma combinação linear de $v_1, \dots, v_k$ é $$c_1 v_1 + c_2 v_2 + \cdots + c_k v_k$$ O espaço gerado $\operatorname{span}{v_1,\dots,v_k}$ é o conjunto de todas essas combinações. Ele é sempre um subespaço. Independência linear</h2> Os vetores $v_1,\dots,v_k$ são linearmente independentes quando $$c_1v_1 + \cdots + c_kv_k = 0 \implies c_1 = \cdots = c_k = 0$$ Ou seja: nenhum deles é combinação dos demais. Dependência significa redundância — informação repetida. Essa é a leitura prática mais útil. Numa matriz de dados em que colunas são atributos, colunas linearmente dependentes significam atributos redundantes; é o que causa multicolinearidade em regressão e o que torna a matriz normal singular. Base e dimensão</h2> Uma base é um conjunto linearmente independente que gera o espaço. Todo espaço vetorial de dimensão finita tem base, e todas as bases têm o mesmo número de elementos — esse número é a dimensão. Numa base ${b_1,\dots,b_n}$, todo vetor se escreve de forma única como combinação dos $b_i$. Os coeficientes são as coordenadas. A base canônica de $\mathbb{R}^3$ é ${(1,0,0), (0,1,0), (0,0,1)}$, mas ela não tem nada de especial matematicamente. Escolher outra base é justamente o que fazem PCA (base que alinha com as direções de maior variância), a transformada de Fourier (base de frequências) e wavelets (base localizada em tempo e escala). Comprimir dados é, em geral, escolher a base em que poucos coeficientes concentram a informação. Subespaços fundamentais</h2> Para uma matriz $A \in \mathbb{R}^{m\times n}$: Subespaço</th> Definição</th> Dimensão</th></tr></thead> Espaço coluna</td> ${Ax}$</td> $r$ (posto)</td></tr> Espaço nulo</td> ${x : Ax = 0}$</td> $n - r$</td></tr> Espaço linha</td> Gerado pelas linhas</td> $r$</td></tr> Espaço nulo à esquerda</td> ${y : A^Ty = 0}$</td> $m - r$</td></tr> </tbody></table> O teorema do posto-nulidade amarra tudo: $$\dim(\text{espaço coluna}) + \dim(\text{espaço nulo}) = n$$ Em termos de sistemas: o posto conta as equações realmente independentes, e a nulidade conta os graus de liberdade da solução. Se $Ax = b$ tem solução e a nulidade é $k$, o conjunto de soluções é um deslocamento de um subespaço de dimensão $k$ — ou seja, há infinitas soluções parametrizadas por $k$ variáveis livres. Exemplo trabalhado</h2> Os vetores $(1,2)$, $(2,4)$ e $(1,0)$ em $\mathbb{R}^2$ são independentes? Não: $(2,4) = 2(1,2)$. Além disso, três vetores em $\mathbb{R}^2$ nunca podem ser independentes — em dimensão $n$, qualquer conjunto com mais de $n$ vetores é dependente. Já ${(1,2), (1,0)}$ é independente e tem dois elementos em espaço de dimensão dois, logo é base. Aplicações em computação</h2> Aprendizado de máquina. O espaço de atributos é um espaço vetorial; embeddings representam palavras e imagens como vetores em que proximidade significa similaridade semântica. Redução de dimensionalidade é projeção em subespaço. Computação gráfica. Posições, normais e cores são vetores. Interpolação entre vértices é combinação linear com pesos baricêntricos. Códigos corretores. Um código linear é um subespaço de $\mathbb{F}_q^n$. A distância mínima do código determina quantos erros ele corrige. Compressão. JPEG projeta blocos numa base de cossenos e descarta coeficientes pequenos; a qualidade da compressão depende inteiramente da escolha da base. Sistemas de recomendação. Fatoração de matrizes representa usuários e itens em um mesmo espaço vetorial de baixa dimensão. Erros comuns</h2> Confundir dimensão com número de vetores. Cinco vetores em $\mathbb{R}^3$ podem gerar o espaço, mas não formam base.</li> Achar que espaço vetorial precisa ser $\mathbb{R}^n$. Funções e polinômios formam espaços vetoriais legítimos.</li> Esquecer que o vetor nulo pertence a todo subespaço. Um conjunto que não o contém não é subespaço.</li> Ignorar dependência quase linear. Numericamente, vetores quase dependentes causam instabilidade mesmo sem serem exatamente dependentes.</li> </ul> Leituras recomendadas</h2> Strang, Introduction to Linear Algebra — a apresentação mais intuitiva; as aulas do MIT 18.06 seguem esse livro e estão disponíveis gratuitamente.</li> Axler, Linear Algebra Done Right — trata autovalores sem determinantes, com foco em estrutura; excelente segunda leitura.</li> Halmos, Finite-Dimensional Vector Spaces — o clássico rigoroso e conciso.</li> Série "Essence of Linear Algebra" do 3Blue1Brown — construção da intuição geométrica em vídeo.</li> </ul> Gilbert Strang (2016). Introduction to Linear Algebra. Wellesley-Cambridge Press. ISBN 9780980232776</a>. Sheldon Axler (2015). Linear Algebra Done Right. Springer. DOI: 10.1007/978-3-319-11080-6</a>. Paul R. Halmos (1974). Finite-Dimensional Vector Spaces. Springer. DOI: 10.1007/978-1-4612-6387-6</a>. Referências</h2> Gilbert Strang (2016). Introduction to Linear Algebra. Wellesley-Cambridge Press.</li> Sheldon Axler (2015). Linear Algebra Done Right. Springer.</li> Paul R. Halmos (1958). Finite-Dimensional Vector Spaces. Van Nostrand.</li> </ol> Matrizes e Operações 2026-07-26T00:00:00+00:00 Matrizes e Operações</h1> 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</h2> 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</h2> $$(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)</code> é a chamada certa; numpy.linalg.inv(A) @ b</code> é o erro que aparece em código de quem aprendeu a fórmula antes do método. Matrizes especiais</h2> Tipo</th> Definição</th> Propriedade útil</th></tr></thead> Identidade $I$</td> $1$ na diagonal, $0$ fora</td> $AI = IA = A$</td></tr> Diagonal</td> Zero fora da diagonal</td> Produto e inversa triviais</td></tr> Triangular</td> Zeros de um lado</td> Sistema resolvido por substituição</td></tr> Simétrica</td> $A = A^T$</td> Autovalores reais, autovetores ortogonais</td></tr> Ortogonal</td> $Q^TQ = I$</td> $Q^{-1} = Q^T$; preserva norma</td></tr> Esparsa</td> Maioria dos elementos nula</td> Armazenamento e produto especializados</td></tr> Definida positiva</td> $x^TAx > 0$ para $x \ne 0$</td> Admite Cholesky</td></tr> </tbody></table> 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</h2> Operação</th> Custo ingênuo</th></tr></thead> Soma</td> $O(mn)$</td></tr> Produto matriz-vetor</td> $O(mn)$</td></tr> Produto matriz-matriz</td> $O(mnp)$</td></tr> Inversa / determinante</td> $O(n^3)$</td></tr> Resolver sistema</td> $O(n^3)$</td></tr> </tbody></table> 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</code></pre> A lição prática: em álgebra linear numérica, nunca escreva o laço. Chame a biblioteca. Traço e posto</h2> 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</h2> $$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</h2> 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</h2> Inverter para resolver sistema. Use solve</code>, não inv</code>.</li> Confundir *</code> com @</code>. Em NumPy, *</code> é produto elemento a elemento.</li> Ignorar broadcasting e obter resultado de forma inesperada sem erro.</li> Escrever laços aninhados em vez de chamar BLAS.</li> Armazenar matriz esparsa densamente.</li> Esquecer que o produto não comuta, sobretudo ao compor transformações gráficas.</li> </ul> Leituras recomendadas</h2> Strang, capítulos 1 a 3 — matrizes com ênfase em interpretação geométrica.</li> Golub e Van Loan, Matrix Computations — a bíblia da álgebra linear numérica; referência para quem implementa.</li> Documentação do NumPy e do SciPy sobre linalg</code> — quando usar cada rotina e o que cada uma assume.</li> Documentação do LAPACK — os nomes das rotinas e suas hipóteses; útil para entender mensagens de erro de bibliotecas de alto nível.</li> </ul> Gilbert Strang (2016). Introduction to Linear Algebra. Wellesley-Cambridge Press. ISBN 9780980232776</a>. Gene H. Golub and Charles F. Van Loan (2013). Matrix Computations. Johns Hopkins University Press. DOI: 10.56021/9781421407944</a>. Referências</h2> Gilbert Strang (2016). Introduction to Linear Algebra. Wellesley-Cambridge Press.</li> Gene H. Golub; Charles F. Van Loan (2013). Matrix Computations. Johns Hopkins University Press.</li> </ol> Ortogonalidade e Fatoração QR 2026-07-26T00:00:00+00:00 Ortogonalidade e Fatoração QR</h1> Ortogonalidade é o conceito que torna a álgebra linear numericamente estável. Transformações ortogonais preservam comprimentos, e por isso não amplificam erro de arredondamento — a razão pela qual os algoritmos confiáveis são construídos sobre elas. Bases ortonormais</h2> Um conjunto ${q_1,\dots,q_n}$ é ortonormal quando $\langle q_i,q_j\rangle = \delta_{ij}$: vetores unitários e mutuamente ortogonais. A vantagem prática é enorme. Numa base qualquer, achar as coordenadas de $v$ exige resolver um sistema. Numa base ortonormal, elas são simples produtos internos: $$v = \sum_i \langle v,q_i\rangle q_i$$ Um problema $O(n^3)$ vira $O(n^2)$. Matrizes ortogonais</h2> $Q$ é ortogonal quando $Q^TQ = I$, isto é, $Q^{-1} = Q^T$. Propriedades decisivas: Preserva norma: $|Qx| = |x|$.</li> Preserva produto interno e ângulos.</li> $|\det Q| = 1$.</li> $\kappa_2(Q) = 1$ — o melhor condicionamento possível.</li> </ul> A última é o ponto central: multiplicar por matriz ortogonal não piora o condicionamento do problema. Toda operação intermediária de um algoritmo estável tende a ser ortogonal por essa razão. Rotações e reflexões são exatamente as transformações ortogonais de $\mathbb{R}^n$. Gram-Schmidt</h2> Transforma uma base qualquer em ortonormal, subtraindo de cada vetor as projeções sobre os anteriores: $$u_k = v_k - \sum_{i<k} \operatorname{proj}_{q_i}(v_k), \qquad q_k = \frac{u_k}{|u_k|}$$ A versão clássica é numericamente instável: os erros de arredondamento fazem a ortogonalidade se degradar ao longo do processo. A versão modificada subtrai as projeções uma a uma, atualizando o vetor a cada passo, e é bem melhor: import numpy as np def gram_schmidt_modificado(V): n, k = V.shape Q = np.zeros((n, k)) R = np.zeros((k, k)) for j in range(k): v = V[:, j].copy() for i in range(j): R[i, j] = Q[:, i] @ v v -= R[i, j] * Q[:, i] # atualiza a cada passo R[j, j] = np.linalg.norm(v) Q[:, j] = v / R[j, j] return Q, R</code></pre> Mesmo assim, para trabalho sério prefira Householder. Fatoração QR</h2> Toda matriz $A \in \mathbb{R}^{m\times n}$ com $m \ge n$ se escreve $$A = QR$$ com $Q$ de colunas ortonormais e $R$ triangular superior. Três métodos de obtê-la: Método</th> Estabilidade</th> Observação</th></tr></thead> Gram-Schmidt clássico</td> Ruim</td> Só didático</td></tr> Gram-Schmidt modificado</td> Razoável</td> Aceitável</td></tr> Householder</td> Excelente</td> Padrão do LAPACK</td></tr> Rotações de Givens</td> Excelente</td> Boa para matrizes esparsas</td></tr> </tbody></table> Refletores de Householder zeram uma coluna inteira de uma vez, refletindo o vetor sobre um hiperplano: $$H = I - 2\frac{vv^T}{v^Tv}$$ Cada $H$ é ortogonal e simétrica. Aplicando $n$ refletores, $A$ vira triangular. Custo: $\frac{2}{3}n^3$ para matriz quadrada — cerca do dobro da eliminação LU, e essa é a moeda de troca: paga-se o dobro por estabilidade muito superior. Rotações de Givens zeram um elemento por vez, o que é preferível quando a matriz já tem muitos zeros ou quando se atualiza uma fatoração existente. QR e mínimos quadrados</h2> Este é o uso mais importante. Para minimizar $|Ax-b|_2$ com $A = QR$: $$|Ax - b| = |QRx - b| = |Rx - Q^Tb|$$ usando que $Q$ preserva norma. Basta então resolver o sistema triangular $Rx = Q^Tb$ por substituição regressiva. A vantagem sobre as equações normais é decisiva: $\kappa(A^TA) = \kappa(A)^2$, enquanto o método QR trabalha com $\kappa(A)$. Em problemas mal condicionados, isso é a diferença entre resultado útil e ruído. import numpy as np Q, R = np.linalg.qr(A) x = np.linalg.solve(R, Q.T @ b) # ou, mais robusto, deixando a biblioteca escolher: x, *_ = np.linalg.lstsq(A, b, rcond=None)</code></pre>Outras aplicações</h2> Algoritmo QR para autovalores. Fatorar e remultiplicar na ordem trocada, repetidamente, converge para forma triangular com os autovalores na diagonal. É o algoritmo padrão do mundo inteiro. Ortogonalização em gráficos. Matrizes de rotação acumuladas ao longo de milhares de quadros perdem ortogonalidade por arredondamento. Reortogonalizar periodicamente evita que a cena comece a distorcer. Redes neurais. Inicialização ortogonal de pesos ajuda a evitar explosão e desaparecimento de gradiente em redes profundas e recorrentes, precisamente porque preserva norma. Compressão e projeções aleatórias. Projeções em subespaços ortonormais aleatórios preservam distâncias aproximadamente — o conteúdo do lema de Johnson-Lindenstrauss. Exemplo trabalhado</h2> Ortonormalizar $v_1 = (1,1,0)$ e $v_2 = (1,0,1)$. $$q_1 = \frac{v_1}{|v_1|} = \frac{1}{\sqrt2}(1,1,0)$$ $$\langle v_2,q_1\rangle = \frac{1}{\sqrt2}, \qquad u_2 = v_2 - \frac{1}{\sqrt2}q_1 = \left(\tfrac12, -\tfrac12, 1\right)$$ $$|u_2| = \sqrt{\tfrac14+\tfrac14+1} = \frac{\sqrt6}{2}, \qquad q_2 = \frac{1}{\sqrt6}(1,-1,2)$$ Conferindo: $\langle q_1,q_2\rangle = \frac{1}{\sqrt{12}}(1 - 1 + 0) = 0$. Ortogonais. Erros comuns</h2> Gram-Schmidt clássico em código de produção.</li> Equações normais em problema mal condicionado.</li> Não reortogonalizar matrizes de rotação acumuladas.</li> Supor que $Q$ é quadrada. Na QR reduzida, $Q$ é $m\times n$ e $QQ^T \ne I$.</li> Ignorar o sinal. A fatoração QR é única a menos de sinais das colunas.</li> </ul> Leituras recomendadas</h2> Trefethen e Bau, lições 7 a 11 — QR, Gram-Schmidt e Householder; a melhor exposição disponível.</li> Golub e Van Loan, capítulo 5 — todos os detalhes de implementação.</li> Documentação do LAPACK, rotinas geqrf</code> e orgqr</code> — o que as bibliotecas realmente fazem.</li> </ul> Lloyd N. Trefethen and David Bau III (1997). Numerical Linear Algebra. SIAM. DOI: 10.1137/1.9780898719574</a>. Gene H. Golub and Charles F. Van Loan (2013). Matrix Computations. Johns Hopkins University Press. DOI: 10.56021/9781421407944</a>. Referências</h2> Lloyd N. Trefethen; David Bau III (1997). Numerical Linear Algebra. SIAM.</li> Gene H. Golub; Charles F. Van Loan (2013). Matrix Computations. Johns Hopkins University Press.</li> </ol> Produto Interno e Normas 2026-07-26T00:00:00+00:00 Produto Interno e Normas</h1> Produto interno e norma acrescentam geometria ao espaço vetorial: comprimento, ângulo, distância e ortogonalidade. Sem eles, um espaço vetorial não sabe o que é "perto". Produto interno</h2> Em $\mathbb{R}^n$: $$\langle u, v \rangle = u^Tv = \sum_{i=1}^{n} u_iv_i$$ Propriedades: simetria, linearidade em cada argumento e positividade ($\langle v,v\rangle > 0$ para $v \ne 0$). A relação com ângulo é o que dá significado geométrico: $$\langle u, v \rangle = |u||v|\cos\theta$$ Daí: $\langle u,v\rangle = 0$ significa ortogonalidade; positivo significa ângulo agudo; negativo, obtuso. Normas vetoriais</h2> Norma</th> Fórmula</th> Nome</th> Uso</th></tr></thead> $|x|_1$</td> $\sum \lvert x_i \rvert$</td> Manhattan</td> Regularização esparsa</td></tr> $|x|_2$</td> $\sqrt{\sum x_i^2}$</td> Euclidiana</td> Distância usual</td></tr> $|x|_\infty$</td> $\max \lvert x_i \rvert$</td> Máximo</td> Erro de pior caso</td></tr> $|x|_p$</td> $(\sum \lvert x_i \rvert^p)^{1/p}$</td> Geral</td> Interpolação entre as anteriores</td></tr> </tbody></table> Toda norma satisfaz positividade, homogeneidade ($|cx| = |c||x|$) e desigualdade triangular ($|x+y| \le |x| + |y|$). Em dimensão finita todas as normas são equivalentes — cada uma limita a outra por constantes. Isso significa que convergência não depende da norma escolhida; o que depende é a geometria da bola unitária, e é aí que a escolha importa na prática. A bola unitária de $\ell_1$ é um losango com vértices sobre os eixos; a de $\ell_2$ é uma esfera. Quando um problema de otimização é resolvido dentro dessas bolas, a de $\ell_1$ tende a produzir soluções nos vértices — isto é, com coordenadas exatamente nulas. É essa a razão geométrica de a regularização $L_1$ (LASSO) produzir modelos esparsos, e a $L_2$ (Ridge) apenas encolher os coeficientes sem zerá-los. Desigualdade de Cauchy-Schwarz</h2> $$|\langle u,v\rangle| \le |u|,|v|$$ com igualdade se e somente se $u$ e $v$ são paralelos. É a desigualdade mais usada da matemática aplicada, e o que garante que $\cos\theta$ definido acima fique entre $-1$ e $1$. Similaridade do cosseno</h2> $$\text{sim}(u,v) = \frac{\langle u,v\rangle}{|u||v|} \in [-1,1]$$ Mede alinhamento ignorando magnitude. É a métrica padrão para comparar embeddings de texto, documentos em modelo vetorial e vetores de recomendação — em todos esses casos, o que importa é a direção, não o tamanho. import numpy as np def cosseno(u, v): return np.dot(u, v) / (np.linalg.norm(u) * np.linalg.norm(v))</code></pre> Se os vetores forem previamente normalizados, a similaridade do cosseno vira simples produto interno — o que permite usar produto matricial e busca por vizinho mais próximo com aceleração de hardware. É o truque usado por todo banco de dados vetorial. Normas matriciais</h2> Norma de Frobenius, análoga à euclidiana: $$|A|F = \sqrt{\sum{i,j} a_{ij}^2} = \sqrt{\operatorname{tr}(A^TA)}$$ Normas induzidas, que medem o fator máximo de ampliação: $$|A|p = \max{x \ne 0} \frac{|Ax|_p}{|x|_p}$$ $|A|_1$: maior soma absoluta de coluna.</li> $|A|_\infty$: maior soma absoluta de linha.</li> $|A|_2$: maior valor singular.</li> </ul> Normas induzidas são submultiplicativas: $|AB| \le |A||B|$. É essa propriedade que permite estimar propagação de erro em cadeias de operações, e é a base da definição do número de condição $\kappa(A) = |A||A^{-1}|$. Projeção ortogonal</h2> A projeção de $v$ sobre $u$: $$\operatorname{proj}_u(v) = \frac{\langle v,u\rangle}{\langle u,u\rangle}u$$ Projeção sobre um subespaço com base ortonormal ${q_1,\dots,q_k}$: $$\operatorname{proj}(v) = \sum_{i=1}^{k} \langle v,q_i\rangle q_i$$ Essa fórmula é o coração de mínimos quadrados (projetar $b$ no espaço coluna de $A$), de Gram-Schmidt e de toda análise em bases ortonormais, incluindo Fourier. Exemplo trabalhado</h2> Para $u = (3,4)$ e $v = (1,0)$: $$|u|_2 = 5, \quad |u|1 = 7, \quad |u|\infty = 4$$ $$\langle u,v\rangle = 3, \quad \cos\theta = \frac{3}{5 \cdot 1} = 0{,}6$$ Cauchy-Schwarz confere: $|3| \le 5 \cdot 1$. Aplicações em computação</h2> Busca vetorial. Bancos como FAISS e pgvector indexam por distância euclidiana ou cosseno; a escolha muda os resultados e precisa ser consistente com o modelo de embedding usado. Regularização. $L_1$ para esparsidade, $L_2$ para estabilidade; a escolha é uma decisão de modelagem, não de gosto. Análise de erro. Normas matriciais quantificam como o erro se propaga em cadeias de operações numéricas. Gráficos. Normalizar vetores normais é obrigatório para iluminação correta; a norma euclidiana aparece em toda medida de distância. Erros comuns</h2> Comparar distâncias euclidianas entre atributos de escalas diferentes, sem padronizar.</li> Confundir similaridade do cosseno com distância. Similaridade maior é melhor; distância menor é melhor.</li> Esquecer a normalização antes de calcular cosseno.</li> Usar norma errada no índice vetorial em relação à usada no treino do modelo.</li> Calcular $|A|_2$ pela definição. É o maior valor singular; obtenha-o da SVD.</li> </ul> Leituras recomendadas</h2> Trefethen e Bau, lições 1 a 3 — normas e condicionamento apresentados com clareza exemplar.</li> Boyd e Vandenberghe, capítulo sobre normas — a conexão com otimização convexa; o livro é gratuito no site de Stanford.</li> Documentação do FAISS e do pgvector — como a escolha de métrica afeta índice e resultado.</li> </ul> Lloyd N. Trefethen and David Bau III (1997). Numerical Linear Algebra. SIAM. DOI: 10.1137/1.9780898719574</a>. Stephen Boyd and Lieven Vandenberghe (2004). Convex Optimization. Cambridge University Press. DOI: 10.1017/cbo9780511804441</a>. Referências</h2> Lloyd N. Trefethen; David Bau III (1997). Numerical Linear Algebra. SIAM.</li> Stephen Boyd; Lieven Vandenberghe (2004). Convex Optimization. Cambridge University Press.</li> </ol> Sistemas Lineares 2026-07-26T00:00:00+00:00 Sistemas Lineares</h1> Resolver $Ax = b$ é o problema computacional mais executado do mundo. Ele aparece dentro de simulação física, ajuste de modelos, otimização, gráficos e praticamente todo método numérico. Formulação</h2> $$\begin{cases} a_{11}x_1 + \cdots + a_{1n}x_n = b_1 \ \vdots \ a_{m1}x_1 + \cdots + a_{mn}x_n = b_m \end{cases} \iff Ax = b$$ Três leituras do mesmo objeto, e cada uma ilumina uma coisa: Por linhas: cada equação é um hiperplano; a solução é a interseção.</li> Por colunas: $b$ é combinação linear das colunas de $A$; existe solução se e somente se $b$ está no espaço coluna.</li> Por transformação: procura-se o vetor que $A$ leva em $b$.</li> </ul> A leitura por colunas é a mais útil, porque responde de imediato à pergunta da existência. Existência e unicidade</h2> Seja $r$ o posto de $A$ e $[A|b]$ a matriz aumentada: Condição</th> Resultado</th></tr></thead> $\operatorname{posto}(A) < \operatorname{posto}([A\vert b])$</td> Sem solução (inconsistente)</td></tr> $\operatorname{posto}(A) = \operatorname{posto}([A\vert b]) = n$</td> Solução única</td></tr> $\operatorname{posto}(A) = \operatorname{posto}([A\vert b]) < n$</td> Infinitas soluções</td></tr> </tbody></table> Quando há infinitas soluções, o conjunto é $x_p + \mathcal{N}(A)$: uma solução particular mais o espaço nulo. O número de variáveis livres é $n - r$. Eliminação gaussiana</h2> O método padrão transforma o sistema em triangular por operações que preservam o conjunto de soluções: trocar linhas, multiplicar linha por escalar não nulo, somar múltiplo de uma linha a outra. def eliminacao(A, b): n = len(A) for k in range(n): # pivoteamento parcial: escolhe o maior pivô em módulo p = max(range(k, n), key=lambda i: abs(A[i][k])) A[k], A[p] = A[p], A[k] b[k], b[p] = b[p], b[k] if abs(A[k][k]) < 1e-12: raise ValueError('matriz singular ou quase singular') for i in range(k + 1, n): f = A[i][k] / A[k][k] for j in range(k, n): A[i][j] -= f * A[k][j] b[i] -= f * b[k] # substituição regressiva x = [0.0] * n for i in reversed(range(n)): x[i] = (b[i] - sum(A[i][j] * x[j] for j in range(i + 1, n))) / A[i][i] return x</code></pre> Custo: $\frac{2}{3}n^3$ operações, dominado pela eliminação. Pivoteamento: por que é obrigatório</h2> Sem pivoteamento, o algoritmo falha ao encontrar pivô nulo — e, pior, produz resultado ruim com pivô pequeno. Considere: $$\begin{pmatrix} 10^{-20} & 1 \ 1 & 1 \end{pmatrix}\begin{pmatrix}x_1\x_2\end{pmatrix} = \begin{pmatrix}1\2\end{pmatrix}$$ Sem trocar linhas, o multiplicador é $10^{20}$, e ao subtrair, o valor $1$ da segunda linha é engolido pelo arredondamento. O resultado sai completamente errado, sem nenhum aviso. Com pivoteamento parcial — trocar para que o maior elemento em módulo da coluna vire pivô — os multiplicadores ficam com módulo $\le 1$ e a amplificação de erro é controlada. É por isso que toda implementação séria pivoteia, e por isso que escrever eliminação "do jeito do livro" sem pivoteamento é um defeito latente. Sistemas sobredeterminados e mínimos quadrados</h2> Com mais equações que incógnitas ($m > n$), em geral não há solução exata. Busca-se então o $x$ que minimiza o resíduo: $$\min_x |Ax - b|_2$$ A condição de otimalidade dá as equações normais: $$A^TA,x = A^Tb$$ Elas resolvem o problema, mas têm um defeito numérico sério: o número de condição de $A^TA$ é o quadrado do de $A$, o que pode destruir a precisão. A prática recomendada é usar a fatoração QR ou a SVD, que resolvem o mesmo problema sem elevar o condicionamento ao quadrado. Mínimos quadrados é exatamente a regressão linear: ajustar um modelo a dados com ruído. import numpy as np x, residuos, posto, sv = np.linalg.lstsq(A, b, rcond=None)</code></pre>Condicionamento</h2> O número de condição mede a sensibilidade da solução a perturbações: $$\kappa(A) = |A| \cdot |A^{-1}|$$ Interpretação prática: com $\kappa(A) \approx 10^k$, perdem-se cerca de $k$ dígitos de precisão. Em precisão dupla (cerca de 16 dígitos), $\kappa = 10^{14}$ deixa apenas dois dígitos confiáveis. Uma matriz mal condicionada é quase singular: pequenas mudanças em $b$ produzem grandes mudanças em $x$. Verifique sempre com numpy.linalg.cond</code> antes de confiar num resultado. Exemplo trabalhado</h2> $$\begin{cases} 2x + y = 5 \ 4x + 3y = 11 \end{cases}$$ Eliminando: $L_2 \leftarrow L_2 - 2L_1$ dá $y = 1$. Substituindo na primeira: $2x + 1 = 5$, logo $x = 2$. Verificando na segunda: $4(2) + 3(1) = 11$. Correto. Aplicações em computação</h2> Regressão. Todo ajuste de mínimos quadrados é um sistema linear. Simulação. Métodos implícitos para equações diferenciais exigem resolver um sistema esparso a cada passo de tempo. Gráficos. Coordenadas baricêntricas, deformação de malhas e iluminação global recaem em sistemas lineares. Otimização. O passo de Newton resolve um sistema com a hessiana a cada iteração. Redes. Análise de circuitos e fluxo em redes por leis de conservação produzem sistemas lineares. Erros comuns</h2> Não pivotear. Perda catastrófica de precisão.</li> Usar equações normais em problema mal condicionado, em vez de QR ou SVD.</li> Comparar com zero exato ao testar singularidade; use tolerância relativa.</li> Ignorar a estrutura. Sistemas esparsos, simétricos ou de banda têm métodos muito mais rápidos.</li> Calcular a inversa. Sempre mais lento e menos estável que fatorar.</li> </ul> Leituras recomendadas</h2> Trefethen e Bau, Numerical Linear Algebra — as 40 lições são a melhor introdução moderna ao assunto; condicionamento e estabilidade tratados com clareza rara.</li> Golub e Van Loan — a referência completa sobre algoritmos matriciais.</li> Documentação do SciPy scipy.linalg</code> — rotinas especializadas para matrizes de banda, simétricas e esparsas.</li> Higham, Accuracy and Stability of Numerical Algorithms — para quem quer entender profundamente o que dá errado e por quê.</li> </ul> Lloyd N. Trefethen and David Bau III (1997). Numerical Linear Algebra. SIAM. DOI: 10.1137/1.9780898719574</a>. Gene H. Golub and Charles F. Van Loan (2013). Matrix Computations. Johns Hopkins University Press. DOI: 10.56021/9781421407944</a>. Nicholas J. Higham (2002). Accuracy and Stability of Numerical Algorithms. SIAM. DOI: 10.1137/1.9780898718027</a>. Referências</h2> Lloyd N. Trefethen; David Bau III (1997). Numerical Linear Algebra. SIAM.</li> Gene H. Golub; Charles F. Van Loan (2013). Matrix Computations. Johns Hopkins University Press.</li> Nicholas J. Higham (2002). Accuracy and Stability of Numerical Algorithms. SIAM.</li> </ol> Decomposição em Valores Singulares 2026-07-26T00:00:00+00:00 Decomposição em Valores Singulares</h1> A SVD é a fatoração mais informativa da álgebra linear. Ela existe para toda matriz — quadrada ou não, singular ou não — e revela posto, condicionamento, subespaços fundamentais e a melhor aproximação de posto baixo. Se você só puder aprender uma decomposição, aprenda esta. Enunciado</h2> Toda $A \in \mathbb{R}^{m\times n}$ se fatora como $$A = U\Sigma V^T$$ com: $U \in \mathbb{R}^{m\times m}$ ortogonal — vetores singulares à esquerda;</li> $\Sigma \in \mathbb{R}^{m\times n}$ diagonal com $\sigma_1 \ge \sigma_2 \ge \cdots \ge 0$ — valores singulares;</li> $V \in \mathbb{R}^{n\times n}$ ortogonal — vetores singulares à direita.</li> </ul> Os valores singulares são as raízes quadradas dos autovalores de $A^TA$, e são sempre reais e não negativos. Interpretação geométrica</h2> Toda transformação linear é a composição de três etapas: uma rotação, um escalonamento ao longo dos eixos, outra rotação. $V^T$ gira o espaço de entrada até alinhar com as direções principais; $\Sigma$ estica cada eixo pelo respectivo $\sigma_i$; $U$ gira o resultado para o espaço de saída. A imagem da esfera unitária por $A$ é sempre um elipsoide cujos semieixos têm comprimentos $\sigma_i$. Essa é a razão de a SVD revelar tanto: ela separa "o quanto" a transformação estica de "para onde" ela aponta. O que a SVD revela</h2> Quantidade</th> Leitura na SVD</th></tr></thead> Posto</td> Número de $\sigma_i > 0$</td></tr> $|A|_2$</td> $\sigma_1$</td></tr> $|A|_F$</td> $\sqrt{\sum \sigma_i^2}$</td></tr> $\kappa_2(A)$</td> $\sigma_1/\sigma_r$</td></tr> Espaço coluna</td> Primeiras $r$ colunas de $U$</td></tr> Espaço nulo</td> Últimas $n-r$ colunas de $V$</td></tr> </tbody></table> Determinar posto numericamente é justamente onde a SVD é insubstituível: em vez de perguntar quais $\sigma_i$ são exatamente zero, conta-se quantos estão acima de uma tolerância. Isso dá o posto numérico, que é a única noção utilizável em ponto flutuante. Aproximação de posto baixo</h2> Escrevendo a SVD como soma de matrizes de posto 1: $$A = \sum_{i=1}^{r} \sigma_i u_i v_i^T$$ e truncando nos $k$ primeiros termos obtém-se $A_k$. O teorema de Eckart-Young garante que $A_k$ é a melhor aproximação de posto $k$, tanto na norma 2 quanto na de Frobenius: $$|A - A_k|2 = \sigma{k+1}$$ Este é um dos resultados mais úteis da matemática aplicada: ele diz não apenas que existe boa aproximação, mas que a SVD a encontra, e quanto erro ela comete. O ganho de armazenamento é direto: em vez de $mn$ números, guardam-se $k(m+n+1)$. import numpy as np U, s, Vt = np.linalg.svd(A, full_matrices=False) k = 50 A_k = (U[:, :k] * s[:k]) @ Vt[:k, :] erro_relativo = s[k] / s[0]</code></pre>Pseudoinversa</h2> $$A^+ = V\Sigma^+U^T$$ com $\Sigma^+$ obtida invertendo os valores singulares não nulos e transpondo. A pseudoinversa dá a solução de norma mínima entre as que minimizam $|Ax-b|$ — resolvendo simultaneamente os casos sobredeterminado e subdeterminado, e funcionando mesmo com $A$ singular. Na prática, valores singulares muito pequenos são zerados antes da inversão (o parâmetro rcond</code>), evitando que ruído seja amplificado por $1/\sigma$ com $\sigma$ minúsculo. Essa regularização por truncamento é a forma mais simples de lidar com problemas mal-postos. Relação com PCA</h2> Centralize os dados na matriz $X$ (amostras nas linhas). Então: A matriz de covariância é $\frac{1}{n-1}X^TX$.</li> Os componentes principais são as colunas de $V$.</li> A variância explicada pelo $i$-ésimo componente é $\sigma_i^2/(n-1)$.</li> </ul> Calcular PCA pela SVD de $X$ é preferível a calcular autovalores de $X^TX$: evita formar o produto, que eleva o condicionamento ao quadrado, e é mais estável. Aplicações em computação</h2> Compressão de imagens. Aplicar SVD a uma imagem e reter poucos termos produz compressão com degradação previsível. Não compete com JPEG na prática, mas é a demonstração mais clara do teorema de Eckart-Young. Sistemas de recomendação. A fatoração da matriz usuário-item em fatores latentes é a base da filtragem colaborativa. Como a matriz real é esparsa e incompleta, usa-se SVD truncada com otimização (mínimos quadrados alternados) em vez da SVD exata. Análise semântica latente. Aplicar SVD à matriz termo-documento revela tópicos como direções no espaço reduzido, agrupando sinônimos. Remoção de ruído. Se o sinal está num subespaço de dimensão baixa e o ruído é espalhado, truncar a SVD limpa o dado. Visão computacional. Estimativa de matriz fundamental, alinhamento de nuvens de pontos (algoritmo de Kabsch) e reconstrução 3D usam SVD para resolver sistemas homogêneos: a solução é o vetor singular associado ao menor valor singular. Diagnóstico numérico. Antes de confiar em qualquer resultado de sistema linear, olhe o espectro de valores singulares. Uma queda abrupta indica posto deficiente; um decaimento suave até valores minúsculos indica mau condicionamento. Exemplo trabalhado</h2> $$A = \begin{pmatrix} 3 & 0 \ 0 & 2 \ 0 & 0 \end{pmatrix}$$ Já está em forma diagonal, então $\sigma_1 = 3$, $\sigma_2 = 2$, com $U$ e $V$ essencialmente identidades. Daí: posto $2$, $|A|_2 = 3$, $|A|_F = \sqrt{13}$, $\kappa_2 = 3/2$. A melhor aproximação de posto 1 é a matriz com apenas o $3$, cometendo erro $|A - A_1|_2 = \sigma_2 = 2$. Erros comuns</h2> Usar full_matrices=True</code> sem necessidade, alocando uma $U$ de $m\times m$ com $m$ enorme.</li> Não centralizar os dados antes de aplicar SVD para PCA — o primeiro componente vira a média.</li> Calcular SVD completa quando só se quer os maiores valores singulares; use métodos truncados (scipy.sparse.linalg.svds</code>) ou aleatorizados.</li> Confundir vetores singulares com autovetores. Coincidem apenas para matrizes simétricas definidas positivas.</li> Esquecer o sinal. Vetores singulares são definidos a menos de sinal, e resultados podem diferir entre bibliotecas.</li> </ul> Leituras recomendadas</h2> Trefethen e Bau, lições 4 a 5 — a melhor introdução curta à SVD, com a interpretação geométrica bem construída.</li> Strang, capítulo 7 — SVD com aplicações e muita intuição.</li> Golub e Van Loan, capítulo 8 — algoritmos de cálculo da SVD.</li> Halko, Martinsson e Tropp, "Finding Structure with Randomness" — SVD aleatorizada, o método prático para matrizes muito grandes.</li> </ul> Lloyd N. Trefethen and David Bau III (1997). Numerical Linear Algebra. SIAM. DOI: 10.1137/1.9780898719574</a>. Gilbert Strang (2016). Introduction to Linear Algebra. Wellesley-Cambridge Press. ISBN 9780980232776</a>. Gene H. Golub and Charles F. Van Loan (2013). Matrix Computations. Johns Hopkins University Press. DOI: 10.56021/9781421407944</a>. Referências</h2> Lloyd N. Trefethen; David Bau III (1997). Numerical Linear Algebra. SIAM.</li> Gilbert Strang (2016). Introduction to Linear Algebra. Wellesley-Cambridge Press.</li> Gene H. Golub; Charles F. Van Loan (2013). Matrix Computations. Johns Hopkins University Press.</li> </ol> Análise Assintótica 2026-07-26T00:00:00+00:00 Análise Assintótica</h1> Análise assintótica descreve como o custo de um algoritmo cresce quando a entrada cresce, ignorando constantes e termos de menor ordem. É a linguagem padrão para comparar algoritmos — e também a fonte de várias conclusões erradas quando aplicada sem cuidado. As cinco notações</h2> Notação</th> Significado</th> Analogia</th></tr></thead> $f = O(g)$</td> $f$ cresce no máximo como $g$</td> $\le$</td></tr> $f = \Omega(g)$</td> $f$ cresce pelo menos como $g$</td> $\ge$</td></tr> $f = \Theta(g)$</td> Mesma ordem</td> $=$</td></tr> $f = o(g)$</td> Estritamente menor</td> $<$</td></tr> $f = \omega(g)$</td> Estritamente maior</td> $>$</td></tr> </tbody></table> Formalmente, $f = O(g)$ quando existem $c > 0$ e $n_0$ tais que $0 \le f(n) \le c,g(n)$ para todo $n \ge n_0$. Pela via dos limites, quando o limite existe: $$\lim_{n\to\infty}\frac{f(n)}{g(n)} = \begin{cases} 0 & \Rightarrow f = o(g) \ c \in (0,\infty) & \Rightarrow f = \Theta(g) \ \infty & \Rightarrow f = \omega(g) \end{cases}$$ Um esclarecimento importante: $O$ é um limite superior, não uma descrição exata. Dizer que a busca binária é $O(n^3)$ é tecnicamente verdadeiro e praticamente inútil. Quando se quer precisão, a notação correta é $\Theta$. Hierarquia de crescimento</h2> $$1 \prec \log\log n \prec \log n \prec \sqrt n \prec n \prec n\log n \prec n^2 \prec n^3 \prec 2^n \prec n! \prec n^n$$ Vale ter uma noção concreta das escalas. Supondo $10^9$ operações por segundo: $n$</th> $n\log n$</th> $n^2$</th> $2^n$</th></tr></thead> $10^3$</td> $10,\mu$s</td> $1$ ms</td> inviável</td></tr> $10^6$</td> $20$ ms</td> $17$ min</td> inviável</td></tr> $10^9$</td> $30$ s</td> $30$ anos</td> inviável</td></tr> </tbody></table> A fronteira prática costuma estar entre $n^2$ e $n^3$: $n = 10^4$ ainda é tratável em $O(n^2)$, mas $n = 10^6$ não é. Regras de manipulação</h2> $$O(f) + O(g) = O(\max(f,g))$$ $$O(f)\cdot O(g) = O(fg)$$ $$O(cf) = O(f)$$ $$\log_a n = \Theta(\log_b n)$$ A última justifica escrever $O(\log n)$ sem base: mudar de base multiplica por constante. Já em $2^n$ versus $3^n$ a base importa — não são da mesma ordem. Algumas simplificações frequentes: $$3n^2 + 5n + 100 = \Theta(n^2), \qquad \log(n!) = \Theta(n\log n)$$ A segunda vem da aproximação de Stirling e é o que dá o limite inferior $\Omega(n\log n)$ para ordenação por comparação. Melhor, médio e pior caso</h2> São dimensões independentes da notação assintótica, e confundi-las é o erro conceitual mais comum da área. Algoritmo</th> Melhor</th> Médio</th> Pior</th></tr></thead> Busca linear</td> $\Theta(1)$</td> $\Theta(n)$</td> $\Theta(n)$</td></tr> Quicksort</td> $\Theta(n\log n)$</td> $\Theta(n\log n)$</td> $\Theta(n^2)$</td></tr> Merge sort</td> $\Theta(n\log n)$</td> $\Theta(n\log n)$</td> $\Theta(n\log n)$</td></tr> Busca em hash</td> $\Theta(1)$</td> $\Theta(1)$</td> $\Theta(n)$</td></tr> </tbody></table> É perfeitamente correto dizer "o pior caso do quicksort é $\Theta(n^2)$" e "o caso médio é $\Theta(n\log n)$" — são afirmações sobre funções diferentes. Análise amortizada</h2> Mede o custo médio por operação numa sequência, o que é diferente do caso médio probabilístico: a amortização é uma garantia determinística sobre a sequência inteira. O exemplo canônico é o vetor dinâmico. Uma inserção individual pode custar $O(n)$ (quando realoca), mas $n$ inserções custam $O(n)$ no total, porque as realocações formam progressão geométrica $1 + 2 + 4 + \cdots + n < 2n$. Logo o custo amortizado é $O(1)$. O método do potencial formaliza: define-se uma função de potencial sobre o estado da estrutura, e o custo amortizado é o custo real mais a variação de potencial. Os limites da análise assintótica</h2> Esta seção é a mais importante da página, porque é o que separa quem usa a ferramenta de quem a idolatra. Constantes importam. Um algoritmo $O(n\log n)$ com constante 1000 perde para um $O(n^2)$ com constante 1 em toda entrada com $n < 10^4$. É por isso que implementações reais de ordenação trocam para inserção em subvetores pequenos. A hierarquia de memória não aparece. Dois algoritmos $\Theta(n)$ podem diferir em uma ordem de grandeza conforme o padrão de acesso. Percorrer um vetor sequencialmente é muito mais rápido que percorrer uma lista ligada de mesmo tamanho, apesar de ambos serem lineares. $n$ é finito. Se a entrada real nunca passa de mil elementos, o comportamento assintótico é irrelevante — meça. O modelo pode não valer. O modelo de custo uniforme supõe operações aritméticas de custo constante, o que deixa de valer com inteiros de precisão arbitrária. A conclusão prática: use análise assintótica para descartar algoritmos claramente inadequados e para entender escalabilidade; use medição para escolher entre candidatos plausíveis. Exemplo trabalhado</h2> Analisar: def f(n): total = 0 for i in range(n): # n iterações for j in range(i, n): # n - i iterações total += 1 return total</code></pre> O total de iterações é $\sum_{i=0}^{n-1}(n-i) = n + (n-1) + \cdots + 1 = \frac{n(n+1)}{2}$. Logo $\Theta(n^2)$. Note que o laço interno não roda $n$ vezes sempre — mas a soma continua sendo quadrática, e o fator $\frac12$ desaparece na notação. Erros comuns</h2> Usar $O$ quando se quer dizer $\Theta$.</li> Confundir pior caso com caso médio.</li> Somar complexidades de laços aninhados em vez de multiplicar.</li> Ignorar o custo de operações "simples" — concatenar cadeias imutáveis num laço é o clássico $O(n^2)$ acidental.</li> Otimizar assintoticamente sem medir, trocando um algoritmo simples e rápido por um sofisticado e lento na faixa de uso real.</li> Esquecer a complexidade de espaço, que às vezes é o gargalo real.</li> </ul> Leituras recomendadas</h2> Cormen et al., capítulo 3 — as definições formais das cinco notações com exercícios.</li> Graham, Knuth e Patashnik, capítulo 9 — assintótica em profundidade, incluindo expansões e a notação $O$ com rigor.</li> Knuth, TAOCP volume 1, seção 1.2.11 — a origem do uso rigoroso dessas notações em computação.</li> Bentley, Programming Pearls — o contraponto empírico: quando a medição contradiz a análise.</li> </ul> Thomas H. Cormen and Charles E. Leiserson and Ronald L. Rivest and Clifford Stein (2009). Introduction to Algorithms. MIT Press. ISBN 9780262533058</a>. Ronald L. Graham and Donald E. Knuth and Oren Patashnik (1994). Concrete Mathematics: A Foundation for Computer Science. Addison-Wesley. ISBN 9780134389967</a>. Donald E. Knuth (1997). The Art of Computer Programming, Volume 1: Fundamental Algorithms. Addison-Wesley. Página oficial</a>. Referências</h2> Thomas H. Cormen; Charles E. Leiserson; Ronald L. Rivest; Clifford Stein (2009). Introduction to Algorithms. MIT Press.</li> Ronald L. Graham; Donald E. Knuth; Oren Patashnik (1994). Concrete Mathematics: A Foundation for Computer Science. Addison-Wesley.</li> Donald E. Knuth (1997). The Art of Computer Programming, Volume 1: Fundamental Algorithms. Addison-Wesley.</li> </ol> Derivadas 2026-07-26T00:00:00+00:00 Derivadas</h1> Derivada é a taxa instantânea de variação — e, mais util ainda, o melhor modelo linear local de uma função. Essa segunda leitura é a que explica por que derivadas dominam a otimização e o aprendizado de máquina. Definição</h2> $$f'(a) = \lim_{h\to 0}\frac{f(a+h)-f(a)}{h}$$ Equivalentemente, $f'(a)$ é o único número tal que $$f(a+h) = f(a) + f'(a)h + o(h)$$ Ou seja: perto de $a$, a função se comporta como uma reta de inclinação $f'(a)$. Todo método de otimização baseado em gradiente explora exatamente essa aproximação — dá um passo confiando que o modelo linear vale numa vizinhança. Diferenciável implica contínua; a recíproca é falsa ($|x|$ em zero). Regras</h2> Regra</th> Fórmula</th></tr></thead> Potência</td> $(x^n)' = nx^{n-1}$</td></tr> Produto</td> $(fg)' = f'g + fg'$</td></tr> Quociente</td> $(f/g)' = \dfrac{f'g - fg'}{g^2}$</td></tr> Cadeia</td> $(f\circ g)'(x) = f'(g(x)),g'(x)$</td></tr> Exponencial</td> $(e^x)' = e^x$</td></tr> Logaritmo</td> $(\ln x)' = 1/x$</td></tr> </tbody></table> A regra da cadeia é a mais importante para computação: ela é literalmente o algoritmo de retropropagação. Uma rede neural é uma composição de funções, e o gradiente da perda em relação a um peso profundo é o produto das derivadas ao longo do caminho. É também a origem do desaparecimento do gradiente: um produto de muitos fatores menores que 1 tende a zero exponencialmente com a profundidade. Conexões residuais existem para criar caminhos em que esse produto não encolhe. Gradiente e derivadas parciais</h2> Para $f: \mathbb{R}^n \to \mathbb{R}$: $$\nabla f = \left(\frac{\partial f}{\partial x_1}, \dots, \frac{\partial f}{\partial x_n}\right)$$ Dois fatos que orientam toda otimização: O gradiente aponta na direção de maior crescimento.</li> Ele é ortogonal às curvas de nível.</li> </ul> Daí o método do gradiente descendente: $$x_{k+1} = x_k - \alpha\nabla f(x_k)$$ Em pontos de mínimo interior, $\nabla f = 0$ — condição necessária, não suficiente. Hessiana</h2> A matriz das segundas derivadas: $$H_{ij} = \frac{\partial^2 f}{\partial x_i \partial x_j}$$ Para $f$ suficientemente regular, $H$ é simétrica (teorema de Schwarz), o que permite usar todo o maquinário de matrizes simétricas. A hessiana classifica pontos críticos: Hessiana</th> Ponto</th></tr></thead> Definida positiva</td> Mínimo local</td></tr> Definida negativa</td> Máximo local</td></tr> Indefinida</td> Sela</td></tr> Semidefinida</td> Inconclusivo</td></tr> </tbody></table> Em dimensão alta, selas são muito mais comuns que mínimos locais — a chance de todos os $n$ autovalores terem o mesmo sinal cai rapidamente com $n$. Esse fato mudou a compreensão de por que o treinamento de redes profundas funciona: o obstáculo prático são as regiões de sela, não mínimos locais ruins. Diferenciação automática</h2> Três formas de obter derivadas em código: Numérica. $f'(x) \approx \frac{f(x+h)-f(x)}{h}$. Simples, mas sofre com o dilema do passo: $h$ grande dá erro de truncamento, $h$ pequeno dá cancelamento catastrófico. O melhor $h$ fica em torno de $\sqrt{\epsilon_{\text{máq}}}$, dando só metade dos dígitos. A diferença centrada $\frac{f(x+h)-f(x-h)}{2h}$ é bem melhor. Simbólica. Manipula expressões e dá fórmula exata, mas sofre com explosão de tamanho. Automática. Aplica a regra da cadeia sobre as operações elementares do programa, com precisão de máquina. É o que PyTorch, JAX e TensorFlow fazem. O modo reverso (retropropagação) calcula o gradiente de uma saída escalar em relação a todas as entradas com custo comparável ao de uma avaliação da função — o que é exatamente o caso do treino de redes, com milhões de parâmetros e uma única perda. O modo direto é preferível na situação oposta: poucas entradas, muitas saídas. import torch x = torch.tensor([2.0], requires_grad=True) y = x**3 + 2*x y.backward() print(x.grad) # 3x² + 2 = 14</code></pre>Teorema do valor médio</h2> Se $f$ é contínua em $[a,b]$ e diferenciável em $(a,b)$, existe $c$ com $$f'(c) = \frac{f(b)-f(a)}{b-a}$$ É a ferramenta que converte informação sobre a derivada em informação sobre a função — a base das estimativas de erro em análise numérica e da prova de que derivada nula em um intervalo implica função constante. Exemplo trabalhado</h2> Minimizar $f(x) = x^2 - 4x + 7$. $f'(x) = 2x - 4 = 0$ dá $x = 2$. Como $f''(x) = 2 > 0$, é mínimo. O valor mínimo é $f(2) = 3$. Com gradiente descendente a partir de $x_0 = 0$ e $\alpha = 0{,}1$: $$x_1 = 0 - 0{,}1(-4) = 0{,}4, \quad x_2 = 0{,}4 - 0{,}1(-3{,}2) = 0{,}72, \quad \dots$$ convergindo para $2$. Note que $\alpha$ grande demais (aqui, $\alpha > 1$) faz a iteração divergir — o limite é $2/L$ com $L$ a constante de Lipschitz do gradiente, que neste caso é 2. Aplicações em computação</h2> Aprendizado de máquina. Todo treino por gradiente; a retropropagação é a regra da cadeia aplicada com memoização. Computação gráfica. Normais de superfície são gradientes; renderização diferenciável permite otimizar cenas a partir de imagens. Física. Forças são gradientes de potencial; integradores numéricos avançam o estado com base em derivadas. Análise de sensibilidade. Derivadas medem quanto uma saída depende de cada entrada — usado em finanças e em interpretabilidade de modelos. Erros comuns</h2> Passo grande demais no gradiente descendente, causando divergência.</li> Confundir mínimo local com global.</li> Usar derivada numérica quando a automática está disponível.</li> Esquecer que ReLU não é diferenciável em zero — na prática usa-se subgradiente, com convenção arbitrária.</li> Acumular gradiente sem zerar entre iterações (o optimizer.zero_grad()</code> esquecido).</li> </ul> Leituras recomendadas</h2> Spivak, Calculus — derivadas com rigor e ótimos exercícios.</li> Nocedal e Wright, Numerical Optimization, capítulos 1 a 3 — derivadas do ponto de vista de quem otimiza.</li> Goodfellow, Bengio e Courville, capítulo 6 — retropropagação explicada como grafo computacional; o livro é gratuito online.</li> Documentação do JAX sobre grad</code>, jacfwd</code> e jacrev</code> — modo direto e reverso na prática.</li> </ul> Michael Spivak (2008). Calculus. Publish or Perish. ISBN 9780914098911</a>. Jorge Nocedal and Stephen J. Wright (2006). Numerical Optimization. Springer. DOI: 10.1007/978-0-387-40065-5</a>. Ian Goodfellow and Yoshua Bengio and Aaron Courville (2016). Deep Learning. MIT Press. ISBN 9780262337373</a>. Referências</h2> Michael Spivak (2008). Calculus. Publish or Perish.</li> Jorge Nocedal; Stephen J. Wright (2006). Numerical Optimization. Springer.</li> Ian Goodfellow; Yoshua Bengio; Aaron Courville (2016). Deep Learning. MIT Press.</li> </ol> Integrais 2026-07-26T00:00:00+00:00 Integrais</h1> Integral é acumulação: soma de infinitas contribuições infinitesimais. Em computação, ela aparece sobretudo em probabilidade contínua (onde probabilidade é área sob a densidade) e em métodos numéricos. Integral de Riemann</h2> Divida $[a,b]$ em $n$ subintervalos e some as áreas dos retângulos: $$\int_a^b f(x),dx = \lim_{n\to\infty}\sum_{i=1}^{n} f(x_i^*),\Delta x$$ Quando o limite existe independentemente da escolha dos pontos, $f$ é integrável. Toda função contínua num intervalo fechado é integrável. A soma de Riemann é literalmente o algoritmo de integração numérica mais simples — o que torna a definição imediatamente implementável. Teorema fundamental do cálculo</h2> Primeira parte. Se $F(x) = \int_a^x f(t),dt$ com $f$ contínua, então $F'(x) = f(x)$. Segunda parte. Se $F' = f$, então $$\int_a^b f(x),dx = F(b) - F(a)$$ Este é um dos grandes resultados da matemática: ele conecta as duas operações centrais do cálculo — derivar e acumular — mostrando que são inversas. Na prática, transforma um limite de somas num cálculo de diferença. Técnicas</h2> Substituição (a regra da cadeia ao contrário): $$\int f(g(x))g'(x),dx = \int f(u),du$$ Por partes (a regra do produto ao contrário): $$\int u,dv = uv - \int v,du$$ Vale registrar um fato prático importante: a maioria das funções não tem primitiva elementar. $e^{-x^2}$, central em estatística, é o exemplo canônico — não existe fórmula fechada em funções elementares para sua integral. É por isso que a distribuição normal usa a função erro e por isso que integração numérica é indispensável. Integrais impróprias</h2> Quando o intervalo é infinito ou a função é ilimitada: $$\int_1^\infty \frac{dx}{x^p} \quad \text{converge} \iff p > 1$$ Compare com a série $\sum 1/n^p$: a condição é a mesma. Isso não é coincidência — é o teste da integral, que relaciona convergência de séries com convergência de integrais e é uma das ferramentas mais úteis para estimar somas. De fato, a aproximação $$\sum_{k=1}^{n} f(k) \approx \int_1^n f(x),dx$$ é o que dá $\sum_{k=1}^n 1/k \approx \ln n$ — o logaritmo que aparece na análise do quicksort e das tabelas hash. Probabilidade contínua</h2> Uma variável aleatória contínua tem densidade $f$ com $$P(a \le X \le b) = \int_a^b f(x),dx, \qquad \int_{-\infty}^{\infty} f(x),dx = 1$$ E o valor esperado: $$E[X] = \int_{-\infty}^{\infty} x f(x),dx$$ Note que $P(X = a) = 0$ para qualquer ponto isolado — em distribuição contínua, a probabilidade de um valor exato é zero. É por isso que se fala em intervalos, e por isso que comparar um número aleatório contínuo com igualdade exata nunca dispara. A função de distribuição acumulada $F(x) = \int_{-\infty}^x f(t),dt$ é o que a maioria das bibliotecas realmente calcula, e sua inversa é o que permite gerar amostras de uma distribuição arbitrária a partir de uma uniforme (o método da transformada inversa). Integração numérica</h2> Método</th> Erro</th> Observação</th></tr></thead> Retângulos</td> $O(h)$</td> Só didático</td></tr> Trapézios</td> $O(h^2)$</td> Simples e razoável</td></tr> Simpson</td> $O(h^4)$</td> Excelente custo-benefício</td></tr> Gauss-Legendre</td> Exato para polinômios de grau $2n-1$</td> Melhor para funções suaves</td></tr> Monte Carlo</td> $O(1/\sqrt{N})$</td> Independente da dimensão</td></tr> </tbody></table> O último merece destaque. Métodos determinísticos sofrem da maldição da dimensionalidade: uma grade com $m$ pontos por eixo tem $m^d$ pontos, o que é inviável para $d$ grande. Monte Carlo converge a $O(1/\sqrt N)$ independentemente da dimensão, e por isso domina integração em dimensão alta. import numpy as np def monte_carlo(f, a, b, n=1_000_000, rng=None): rng = rng or np.random.default_rng() x = rng.uniform(a, b, n) return (b - a) * np.mean(f(x))</code></pre> É exatamente por isso que Monte Carlo é a base de renderização por traçado de caminhos (integral sobre todos os caminhos de luz), de inferência bayesiana (integrais sobre espaços de parâmetros) e de precificação de derivativos. Exemplo trabalhado</h2> $$\int_0^1 x^2,dx = \left[\frac{x^3}{3}\right]_0^1 = \frac13$$ Pela regra do trapézio com $n = 4$ ($h = 0{,}25$): $$\frac{h}{2}\left[f(0) + 2f(0{,}25) + 2f(0{,}5) + 2f(0{,}75) + f(1)\right] = \frac{0{,}25}{2}[0 + 0{,}125 + 0{,}5 + 1{,}125 + 1] = 0{,}34375$$ Erro de cerca de $0{,}0104$. Com Simpson e os mesmos pontos o resultado é exato, porque Simpson integra polinômios de grau até 3 sem erro. Aplicações em computação</h2> Renderização. A equação de renderização é uma integral sobre direções de luz; traçado de caminhos é sua estimativa por Monte Carlo, e o ruído da imagem é a variância do estimador. Aprendizado bayesiano. A distribuição a posteriori exige integrais que raramente têm forma fechada; daí MCMC e inferência variacional. Processamento de sinais. A transformada de Fourier contínua é uma integral; a versão discreta é sua aproximação. Física. Integradores numéricos avançam simulações no tempo acumulando forças. Erros comuns</h2> Procurar primitiva elementar de funções que não têm.</li> Ignorar singularidades ao integrar numericamente — perto de uma assíntota os métodos padrão falham.</li> Usar grade regular em dimensão alta.</li> Esquecer o jacobiano na mudança de variáveis.</li> Confundir densidade com probabilidade. A densidade pode ser maior que 1; a probabilidade não.</li> </ul> Leituras recomendadas</h2> Stewart, Calculus — técnicas de integração com muitos exercícios.</li> Rudin, capítulo 6 — a integral de Riemann-Stieltjes com rigor.</li> Burden e Faires, capítulo 4 — integração numérica com análise de erro.</li> Pharr, Jakob e Humphreys, Physically Based Rendering — Monte Carlo aplicado a integrais de renderização; gratuito online.</li> </ul> James Stewart (2015). Calculus: Early Transcendentals. Cengage Learning. ISBN 9781285740621</a>. Walter Rudin (1976). Principles of Mathematical Analysis. McGraw-Hill. ISBN 9780070856134</a>. Richard L. Burden and J. Douglas Faires and Annette M. Burden (2015). Numerical Analysis. Cengage Learning. ISBN 9781305253667</a>. Referências</h2> James Stewart (2015). Calculus: Early Transcendentals. Cengage Learning.</li> Walter Rudin (1976). Principles of Mathematical Analysis. McGraw-Hill.</li> Richard L. Burden; J. Douglas Faires; Annette M. Burden (2015). Numerical Analysis. Cengage Learning.</li> </ol> Limites e Continuidade 2026-07-26T00:00:00+00:00 Limites e Continuidade</h1> Limite é o conceito que dá sentido a "aproximar-se sem necessariamente alcançar". É a base de derivada, integral, série e de toda a análise assintótica. Definição épsilon-delta</h2> $$\lim_{x \to a} f(x) = L \iff \forall \varepsilon > 0; \exists \delta > 0: 0 < |x-a| < \delta \implies |f(x)-L| < \varepsilon$$ A leitura como jogo ajuda: alguém escolhe uma tolerância $\varepsilon$ na saída; você precisa exibir uma tolerância $\delta$ na entrada que a garanta. Se consegue responder a qualquer $\varepsilon$, o limite existe. Note a condição $0 < |x-a|$: o valor de $f$ em $a$ é irrelevante para o limite. Essa é a razão de o limite conseguir descrever buracos e descontinuidades. Limites laterais e infinitos</h2> $\lim_{x\to a^-}$ e $\lim_{x\to a^+}$ aproximam-se pela esquerda e pela direita. O limite existe se e somente se os dois existem e coincidem. Limites no infinito descrevem comportamento assintótico, e são exatamente os que aparecem em análise de algoritmos: $$\lim_{n \to \infty} \frac{3n^2 + 5n}{n^2} = 3$$ Continuidade</h2> $f$ é contínua em $a$ quando $$\lim_{x\to a} f(x) = f(a)$$ o que exige três coisas: o limite existe, $f(a)$ existe, e são iguais. Intuitivamente, o gráfico não tem saltos nem buracos. Somas, produtos, quocientes (com denominador não nulo) e composições de contínuas são contínuas — o que permite concluir continuidade sem voltar à definição. Teorema do valor intermediário</h2> Se $f$ é contínua em $[a,b]$ e $y$ está entre $f(a)$ e $f(b)$, então existe $c \in [a,b]$ com $f(c) = y$. O caso $y = 0$ é o mais usado: se $f(a)$ e $f(b)$ têm sinais opostos, existe raiz no intervalo. Esse é exatamente o fundamento do método da bisseção: def bissecao(f, a, b, tol=1e-10, max_iter=200): fa, fb = f(a), f(b) if fa * fb > 0: raise ValueError('f(a) e f(b) precisam ter sinais opostos') for _ in range(max_iter): m = (a + b) / 2 # evita estouro melhor que (a+b)/2 em inteiros fm = f(m) if fm == 0 or (b - a) / 2 < tol: return m if fa * fm < 0: b, fb = m, fm else: a, fa = m, fm return (a + b) / 2</code></pre> A bisseção converge sempre, desde que a hipótese de sinais opostos valha. O intervalo cai pela metade a cada passo, então são necessárias $\log_2((b-a)/\text{tol})$ iterações — cerca de 50 para precisão de máquina em precisão dupla. É lenta comparada a Newton, mas é a única que não pode falhar. A mesma ideia é a busca binária: nela, a função "está à esquerda do alvo" é monótona, e o teorema garante que o ponto de virada existe. Teorema de Weierstrass</h2> Uma função contínua num intervalo fechado e limitado atinge máximo e mínimo. As duas hipóteses são essenciais. Em $(0,1)$, $f(x) = 1/x$ é contínua e não tem máximo. Em otimização, é este teorema que garante que um mínimo existe antes de qualquer algoritmo sair procurando por ele — e é por isso que restringir o domínio a um conjunto compacto costuma ser o primeiro passo de uma formulação bem posta. Continuidade uniforme e a lipschitziana</h2> $f$ é uniformemente contínua quando o mesmo $\delta$ serve para todo o domínio, e lipschitziana com constante $L$ quando $$|f(x) - f(y)| \le L|x-y|$$ A condição de Lipschitz é a que mais aparece em computação. Ela limita quanto a saída pode variar em resposta à entrada, e é hipótese de: Convergência de gradiente descendente, cuja taxa de passo admissível é $1/L$ com $L$ a constante de Lipschitz do gradiente;</li> Teorema do ponto fixo de Banach, que garante convergência de iterações contrativas;</li> Robustez de redes neurais, em que limitar a constante de Lipschitz limita a sensibilidade a perturbações adversariais.</li> </ul> Descontinuidades</h2> Tipo</th> Descrição</th></tr></thead> Removível</td> O limite existe mas difere de $f(a)$</td></tr> Salto</td> Limites laterais existem e diferem</td></tr> Essencial</td> Algum limite lateral não existe</td></tr> </tbody></table> Funções de arredondamento, floor</code> e ceil</code> têm descontinuidades de salto nos inteiros — o que explica por que otimização com variáveis inteiras não pode usar métodos baseados em derivada. Exemplo trabalhado</h2> Provar que $\lim_{x\to 2}(3x+1) = 7$. Dado $\varepsilon > 0$, queremos $|3x+1-7| < \varepsilon$, ou seja, $3|x-2| < \varepsilon$. Basta tomar $\delta = \varepsilon/3$: se $|x-2| < \delta$, então $|3x-6| = 3|x-2| < 3\delta = \varepsilon$. $\blacksquare$ Para funções lineares o $\delta$ sai diretamente do coeficiente angular — que é justamente a constante de Lipschitz. Aplicações em computação</h2> Métodos numéricos. Convergência de qualquer iteração é um enunciado sobre limites. Análise assintótica. $O$, $\Omega$ e $\Theta$ se definem por limites de razões. Otimização. Continuidade e diferenciabilidade decidem que família de método é aplicável. Gráficos. Interpolação contínua entre quadros-chave; descontinuidade aparece como artefato visível. Ponto flutuante. A aritmética de máquina é descontínua em relação aos reais — pequenas mudanças na entrada podem produzir saltos por arredondamento, e é por isso que testar igualdade exata de floats é um erro. Erros comuns</h2> Supor que $\lim_{x\to a} f(x) = f(a)$ sem verificar continuidade.</li> Concluir existência do limite sem checar os dois limites laterais.</li> Aplicar Weierstrass em intervalo aberto ou ilimitado.</li> Confundir contínua com diferenciável. $|x|$ é contínua e não diferenciável em zero — motivo pelo qual ReLU exige subgradiente.</li> Usar bisseção sem verificar a troca de sinal.</li> </ul> Leituras recomendadas</h2> Rudin, Principles of Mathematical Analysis, capítulo 4 — continuidade com rigor total; o livro é famoso pela concisão.</li> Spivak, Calculus — a melhor ponte entre cálculo operacional e análise rigorosa.</li> Burden e Faires, capítulo 2 — bisseção, ponto fixo e Newton com análise de erro.</li> </ul> Walter Rudin (1976). Principles of Mathematical Analysis. McGraw-Hill. ISBN 9780070856134</a>. Michael Spivak (2008). Calculus. Publish or Perish. ISBN 9780914098911</a>. Referências</h2> Walter Rudin (1976). Principles of Mathematical Analysis. McGraw-Hill.</li> Michael Spivak (2008). Calculus. Publish or Perish.</li> </ol> Séries de Taylor 2026-07-26T00:00:00+00:00 Séries de Taylor</h1> Taylor é a ideia de aproximar uma função complicada por um polinômio, usando as derivadas num ponto. É a ferramenta que sustenta praticamente todo método numérico e que explica como bibliotecas matemáticas calculam seno, exponencial e logaritmo. Polinômio de Taylor</h2> $$P_n(x) = \sum_{k=0}^{n} \frac{f^{(k)}(a)}{k!}(x-a)^k$$ Ele é o único polinômio de grau $n$ que coincide com $f$ em $a$ e tem as mesmas $n$ primeiras derivadas ali. Quanto maior o grau, melhor a aproximação perto de $a$ — e não necessariamente longe. Os casos de ordem baixa já são muito usados: $n=1$: $f(a) + f'(a)(x-a)$ — a reta tangente, base do método de Newton e do gradiente descendente.</li> $n=2$: acrescenta $\frac{f''(a)}{2}(x-a)^2$ — a parábola osculadora, base dos métodos de segunda ordem.</li> </ul> Resto</h2> $$f(x) = P_n(x) + R_n(x), \qquad R_n(x) = \frac{f^{(n+1)}(\xi)}{(n+1)!}(x-a)^{n+1}$$ para algum $\xi$ entre $a$ e $x$ (forma de Lagrange). O resto é o que transforma Taylor de aproximação informal em ferramenta rigorosa: ele limita o erro. Toda estimativa de erro em análise numérica — de diferenças finitas, de Simpson, de métodos de Runge-Kutta — sai de um termo de resto de Taylor. Séries importantes</h2> $$e^x = \sum_{k=0}^{\infty}\frac{x^k}{k!}, \qquad x \in \mathbb{R}$$ $$\sin x = x - \frac{x^3}{3!} + \frac{x^5}{5!} - \cdots$$ $$\cos x = 1 - \frac{x^2}{2!} + \frac{x^4}{4!} - \cdots$$ $$\frac{1}{1-x} = \sum_{k=0}^{\infty}x^k, \qquad |x|<1$$ $$\ln(1+x) = x - \frac{x^2}{2} + \frac{x^3}{3} - \cdots, \qquad |x| \le 1,, x \ne -1$$ O raio de convergência importa: a série de $\frac{1}{1-x}$ diverge para $|x| \ge 1$ mesmo a função estando definida ali. Usar uma série fora do seu raio é um erro que produz lixo silenciosamente. Aproximações de primeira ordem</h2> Para $|x| \ll 1$: $$e^x \approx 1+x, \qquad \sin x \approx x, \qquad \ln(1+x) \approx x, \qquad (1+x)^n \approx 1+nx$$ Essas aproximações aparecem o tempo todo em análise de desempenho e em estimativas rápidas. "Se a probabilidade de falha por requisição é $p$ e há $n$ requisições, a probabilidade de alguma falhar é $1-(1-p)^n \approx np$" é exatamente a última. Precisão numérica</h2> Aqui Taylor deixa de ser teoria e vira engenharia. Considere calcular $e^x - 1$ para $x$ muito pequeno: em ponto flutuante, $e^x$ arredonda para $1$ e a subtração devolve zero — perdendo toda a informação. A série resolve: $$e^x - 1 = x + \frac{x^2}{2} + \frac{x^3}{6} + \cdots$$ que para $x$ pequeno é essencialmente $x$, sem cancelamento. É por isso que bibliotecas oferecem expm1(x)</code> e log1p(x)</code> — funções cuja existência só se justifica por esse fenômeno. import math x = 1e-16 print(math.exp(x) - 1) # 0.0 — errado print(math.expm1(x)) # 1e-16 — correto</code></pre> Bibliotecas matemáticas raramente usam Taylor puro: preferem aproximações minimax (Remez) ou aproximantes de Padé, que distribuem o erro uniformemente pelo intervalo em vez de concentrá-lo longe do ponto de expansão. Mas a redução de argumento que precede essas aproximações se justifica com Taylor. Taylor em várias variáveis</h2> $$f(x + \Delta) \approx f(x) + \nabla f(x)^T\Delta + \frac12\Delta^TH(x)\Delta$$ Esta expressão é a base de toda a otimização de segunda ordem. Minimizar o lado direito em $\Delta$ dá o passo de Newton: $$\Delta = -H^{-1}\nabla f$$ que converge quadraticamente perto do mínimo, contra a convergência linear do gradiente descendente. O custo é resolver um sistema com a hessiana a cada passo — daí os métodos quase-Newton (BFGS, L-BFGS), que aproximam $H^{-1}$ a partir do histórico de gradientes. Exemplo trabalhado</h2> Aproximar $\sqrt{4{,}1}$ com Taylor de primeira ordem em $a = 4$. Com $f(x) = \sqrt{x}$, temos $f'(x) = \frac{1}{2\sqrt x}$, logo $f'(4) = 0{,}25$: $$\sqrt{4{,}1} \approx 2 + 0{,}25 \cdot 0{,}1 = 2{,}025$$ O valor real é $2{,}024845\ldots$, erro de cerca de $1{,}5\times10^{-4}$. O termo de resto prevê isso: $f''(x) = -\frac{1}{4x^{3/2}}$, e $|R_1| \le \frac{|f''(4)|}{2}(0{,}1)^2 = \frac{0{,}03125}{2}\cdot0{,}01 \approx 1{,}6\times10^{-4}$. A previsão bate com o erro observado. Aplicações em computação</h2> Métodos numéricos. Diferenças finitas, Runge-Kutta e regras de quadratura são todos derivados de expansões de Taylor, e suas ordens de erro vêm do primeiro termo desprezado. Otimização. Newton, quase-Newton e região de confiança são modelos de Taylor de segunda ordem. Bibliotecas matemáticas. Redução de argumento seguida de aproximação polinomial. Física em jogos. Integradores como Verlet vêm de expandir a posição em Taylor e cancelar termos ímpares, o que dá precisão de segunda ordem com o mesmo custo. Análise de erro. Propagação de incerteza usa a expansão de primeira ordem. Erros comuns</h2> Usar a série fora do raio de convergência.</li> Truncar sem estimar o resto.</li> Confundir aproximação local com global. Taylor é bom perto de $a$.</li> Esperar convergência de série de Taylor para toda função suave. Existem funções infinitamente diferenciáveis cuja série de Taylor converge para outra coisa.</li> Somar termos alternados de módulo grande, sofrendo cancelamento.</li> </ul> Leituras recomendadas</h2> Rudin, capítulo 5 — teorema de Taylor com o resto demonstrado.</li> Burden e Faires, capítulo 1 — Taylor como ferramenta central de análise numérica.</li> Goldberg, "What Every Computer Scientist Should Know About Floating-Point Arithmetic" — por que expm1</code> e log1p</code> existem.</li> Muller, Elementary Functions — como bibliotecas realmente implementam funções transcendentes.</li> </ul> Walter Rudin (1976). Principles of Mathematical Analysis. McGraw-Hill. ISBN 9780070856134</a>. Richard L. Burden and J. Douglas Faires and Annette M. Burden (2015). Numerical Analysis. Cengage Learning. ISBN 9781305253667</a>. David Goldberg (1991). What Every Computer Scientist Should Know About Floating-Point Arithmetic. ACM Computing Surveys 23(1), 5-48. DOI: 10.1145/103162.103163</a>. Referências</h2> Walter Rudin (1976). Principles of Mathematical Analysis. McGraw-Hill.</li> Richard L. Burden; J. Douglas Faires; Annette M. Burden (2015). Numerical Analysis. Cengage Learning.</li> David Goldberg (1991). What Every Computer Scientist Should Know About Floating-Point Arithmetic. ACM Computing Surveys 23(1), 5-48.</li> </ol> Autômatos e Linguagens Formais 2026-07-26T00:00:00+00:00 Autômatos e Linguagens Formais</h1> Um autômato finito é o modelo de computação mais simples que existe: memória constante, uma passada pela entrada. Apesar da limitação, ele descreve exatamente o poder das expressões regulares e é a base de analisadores léxicos, validadores de protocolo e busca de padrões. Alfabetos e linguagens</h2> Um alfabeto $\Sigma$ é um conjunto finito de símbolos; uma cadeia é uma sequência finita deles; uma linguagem é um conjunto de cadeias. $\Sigma^*$ denota todas as cadeias sobre $\Sigma$, incluindo a vazia $\varepsilon$. Autômato finito determinístico</h2> Uma quíntupla $(Q, \Sigma, \delta, q_0, F)$: estados, alfabeto, função de transição, estado inicial e estados de aceitação. O autômato lê a entrada símbolo a símbolo e aceita se termina em estado de $F$. Note o que ele não tem: nenhuma memória além do estado atual. Com $|Q|$ estados, ele distingue no máximo $|Q|$ situações diferentes. def aceita(delta, q0, finais, cadeia): q = q0 for c in cadeia: q = delta.get((q, c)) if q is None: return False return q in finais</code></pre> Custo: $O(n)$ em tempo e $O(1)$ em espaço. É por isso que autômatos são usados em processamento de fluxo — validar um bilhão de linhas não exige memória crescente. Não determinismo</h2> Um AFN pode ter várias transições para o mesmo símbolo e transições vazias. Ele aceita se algum caminho leva a estado final. O resultado central: AFD e AFN reconhecem exatamente as mesmas linguagens. A construção de subconjuntos converte um AFN de $n$ estados num AFD de até $2^n$ estados. O não determinismo não acrescenta poder, mas acrescenta concisão — e essa explosão exponencial é exatamente a razão de algumas expressões regulares causarem lentidão catastrófica. Expressões regulares</h2> O teorema de Kleene garante a equivalência: uma linguagem é reconhecida por autômato finito se e somente se é descrita por expressão regular. Operações: união, concatenação e fecho de Kleene. Um alerta prático importante: as "expressões regulares" da maioria das linguagens de programação não são regulares. Retrovisores (\1</code>) e lookahead acrescentam poder além dos autômatos finitos, e são implementados por retrocesso — o que abre a porta para ReDoS, negação de serviço por expressão regular. Um padrão como (a+)+b</code> sobre uma entrada de 30 letras a</code> pode levar horas. Motores baseados em autômatos (RE2, o motor de regex do Rust, grep</code>) garantem tempo linear ao custo de não suportar retrovisores. Em código que processa entrada não confiável, essa é a escolha certa. Lema do bombeamento</h2> Para provar que uma linguagem não é regular. Se $L$ é regular, existe $p$ tal que toda cadeia $s \in L$ com $|s| \ge p$ se decompõe em $s = xyz$ com $|y| > 0$, $|xy| \le p$ e $xy^iz \in L$ para todo $i \ge 0$. A intuição é a casa dos pombos: com mais símbolos que estados, algum estado se repete, e o trecho entre as repetições pode ser bombeado. Exemplo: $L = {a^nb^n}$ não é regular. Tomando $s = a^pb^p$, o trecho $y$ está inteiramente nos $a$; bombeando, desequilibra-se a contagem. Este resultado explica por que não se deve analisar HTML ou linguagens balanceadas com expressão regular. Balanceamento exige contagem ilimitada, e autômatos finitos não contam. Hierarquia de Chomsky</h2> Tipo</th> Linguagem</th> Reconhecedor</th> Exemplo</th></tr></thead> 3</td> Regular</td> Autômato finito</td> Identificadores, números</td></tr> 2</td> Livre de contexto</td> Autômato com pilha</td> Expressões aninhadas</td></tr> 1</td> Sensível ao contexto</td> Autômato linearmente limitado</td> $a^nb^nc^n$</td></tr> 0</td> Recursivamente enumerável</td> Máquina de Turing</td> Tudo computável</td></tr> </tbody></table> A hierarquia é estrita: cada nível é estritamente mais poderoso. Em compiladores, a divisão é direta: o analisador léxico usa linguagens regulares (identificadores, números, operadores) e o sintático usa livres de contexto (estrutura aninhada). Verificações que exigem contexto — como "a variável foi declarada" — ficam para a análise semântica, porque estão além do que a gramática expressa. Propriedades de fechamento</h2> Linguagens regulares são fechadas para união, interseção, complemento, concatenação, fecho e reverso. O fechamento por complemento é útil na prática: para verificar se um autômato aceita algo que não deveria, complementa-se e testa-se vaziedade. É a base de várias ferramentas de verificação de protocolo. Minimização</h2> Todo AFD tem um AFD mínimo único (a menos de renomeação), obtido fundindo estados indistinguíveis. O algoritmo de Hopcroft roda em $O(n\log n)$. A relação "ser indistinguível" é uma relação de equivalência, e a minimização é o cálculo de suas classes — uma aplicação direta do conceito de partição. Exemplo trabalhado</h2> Autômato que aceita cadeias sobre ${0,1}$ com número par de zeros. Dois estados: $q_0$ (par, aceitação) e $q_1$ (ímpar). Estado</th> 0</th> 1</th></tr></thead> $q_0$</td> $q_1$</td> $q_0$</td></tr> $q_1$</td> $q_0$</td> $q_1$</td></tr> </tbody></table> O símbolo 1 não altera o estado; o 0 alterna. Note que dois estados bastam para uma propriedade sobre cadeias de comprimento ilimitado — o autômato guarda apenas a paridade, não a contagem. Aplicações em computação</h2> Análise léxica. Ferramentas como lex e flex geram autômatos a partir de expressões regulares. Busca em texto. Knuth-Morris-Pratt e Aho-Corasick constroem autômatos para busca em tempo linear. Validação de protocolo. Máquinas de estado descrevem estados válidos de TCP, de uma conexão TLS ou de um fluxo de pedido. Verificação de modelos. Propriedades temporais viram autômatos sobre palavras infinitas. Interfaces. Fluxos de navegação e estados de componente são máquinas de estado. Erros comuns</h2> Analisar linguagens aninhadas com regex.</li> Expor regex com retrocesso a entrada não confiável (ReDoS).</li> Supor que a regex da linguagem é regular.</li> Confundir não determinismo com aleatoriedade.</li> Esquecer o caso da cadeia vazia ao projetar autômatos.</li> </ul> Leituras recomendadas</h2> Sipser, Introduction to the Theory of Computation, capítulo 1 — a melhor introdução; clara e rigorosa.</li> Hopcroft, Motwani e Ullman — cobertura mais ampla, com muitos algoritmos.</li> Russ Cox, "Regular Expression Matching Can Be Simple And Fast" — por que autômatos vencem retrocesso; leitura essencial.</li> Documentação do RE2 e do crate regex</code> do Rust — garantias de tempo linear na prática.</li> </ul> Michael Sipser (2012). Introduction to the Theory of Computation. Cengage Learning. ISBN 9781133187790</a>. John E. Hopcroft and Rajeev Motwani and Jeffrey D. Ullman (2006). Introduction to Automata Theory, Languages, and Computation. Pearson. ISBN 9780321455369</a>. Referências</h2> Michael Sipser (2012). Introduction to the Theory of Computation. Cengage Learning.</li> John E. Hopcroft; Rajeev Motwani; Jeffrey D. Ullman (2006). Introduction to Automata Theory, Languages, and Computation. Pearson.</li> </ol> Classes P, NP e Reduções 2026-07-26T00:00:00+00:00 Classes P, NP e Reduções</h1> Saber que um problema é NP-completo é uma das informações mais úteis que se pode ter sobre ele — não porque resolve, mas porque redireciona o esforço. Deixa-se de procurar algoritmo exato eficiente e passa-se a buscar aproximação, heurística ou restrição do caso de uso. As classes</h2> P: problemas de decisão resolvíveis em tempo polinomial por máquina determinística. NP: problemas cuja solução pode ser verificada em tempo polinomial. Equivalentemente, resolvíveis em tempo polinomial por máquina não determinística. A leitura por verificação é a mais útil. Um problema está em NP quando, dado um certificado, é fácil conferir. Fatorar está em NP: verificar que $p\cdot q = n$ é uma multiplicação. $$P \subseteq NP$$ Se dá para resolver rápido, dá para verificar rápido. A questão de um milhão de dólares é se a inclusão é estrita. P versus NP</h2> A crença amplamente compartilhada é que $P \ne NP$, mas não há prova. As implicações de $P = NP$ seriam extraordinárias: criptografia de chave pública desabaria, e encontrar demonstrações matemáticas seria tão fácil quanto verificá-las. NP-completude</h2> Um problema é NP-difícil quando todo problema de NP se reduz a ele em tempo polinomial. É NP-completo quando é NP-difícil e pertence a NP. Os NP-completos são os problemas mais difíceis de NP: resolver um deles em tempo polinomial resolveria todos. Teorema de Cook-Levin (1971). SAT é NP-completo. Foi o primeiro, e é a partir dele que todos os outros são provados por redução. Reduções</h2> $A \le_p B$ significa que existe transformação polinomial de instâncias de $A$ em instâncias de $B$ preservando a resposta. O sentido da redução é a fonte do erro mais comum. Para provar que $B$ é NP-difícil, reduz-se um problema conhecidamente difícil $A$ a $B$ — ou seja, mostra-se que $B$ é pelo menos tão difícil quanto $A$. A direção contrária não prova nada sobre a dificuldade de $B$. Cadeia clássica de reduções: $$\text{SAT} \le_p \text{3-SAT} \le_p \text{Clique} \le_p \text{Cobertura por vértices} \le_p \text{Conjunto independente}$$ Problemas NP-completos comuns</h2> Problema</th> Descrição</th></tr></thead> SAT / 3-SAT</td> Satisfatibilidade booleana</td></tr> Clique</td> Existe clique de tamanho $k$?</td></tr> Cobertura por vértices</td> Existe cobertura de tamanho $k$?</td></tr> Ciclo hamiltoniano</td> Existe ciclo que passa por todos os vértices?</td></tr> Caixeiro viajante (decisão)</td> Existe rota de custo $\le k$?</td></tr> Mochila</td> Existe subconjunto de valor $\ge v$ e peso $\le w$?</td></tr> Coloração ($k \ge 3$)</td> O grafo é $k$-colorível?</td></tr> Partição</td> Dividir em dois conjuntos de soma igual?</td></tr> Programação inteira</td> Existe solução inteira viável?</td></tr> </tbody></table> Vale notar as fronteiras: 2-SAT está em P, mas 3-SAT é NP-completo; 2-coloração está em P, 3-coloração é NP-completa; ciclo euleriano está em P, hamiltoniano é NP-completo. Diferenças mínimas no enunciado atravessam a fronteira. O que fazer com um problema NP-difícil</h2> Esta é a parte prática, e é o motivo de a classificação importar. Algoritmos de aproximação. Garantem uma razão em relação ao ótimo. Cobertura por vértices tem aproximação simples de fator 2; o caixeiro viajante métrico tem fator 1,5 (Christofides). Heurísticas. Sem garantia, mas boas na prática: busca local, algoritmos genéricos, recozimento simulado. Resolvedores. Resolvedores SAT e ILP modernos lidam com instâncias industriais de milhões de variáveis. A dificuldade de pior caso não impede eficiência nos casos que aparecem na prática — essa distinção é frequentemente esquecida. Parametrização. Complexidade parametrizada isola a explosão num parâmetro pequeno: cobertura por vértices é resolvível em $O(2^k n)$, tratável quando $k$ é pequeno. Casos especiais. Muitos problemas NP-difíceis viram polinomiais em grafos de estrutura restrita (planares, cordais, de largura em árvore limitada). Relaxar o requisito. Talvez não seja preciso o ótimo. Uma solução 5% pior obtida em segundos costuma valer mais que a ótima em semanas. Outras classes</h2> Classe</th> Descrição</th></tr></thead> co-NP</td> Complementos de problemas de NP</td></tr> PSPACE</td> Espaço polinomial; contém NP</td></tr> EXPTIME</td> Tempo exponencial; sabidamente $\ne$ P</td></tr> BPP</td> Polinomial aleatorizado com erro limitado</td></tr> BQP</td> Polinomial quântico</td></tr> #P</td> Contagem de soluções</td></tr> </tbody></table> Fatoração está em NP e co-NP, e não se acredita que seja NP-completa — o que é relevante, porque significa que quebrar RSA não implicaria $P = NP$. Exemplo trabalhado</h2> Por que 3-SAT se reduz a Clique? Dada uma fórmula com $m$ cláusulas de 3 literais, construa um grafo com um vértice para cada literal de cada cláusula. Ligue dois vértices quando estão em cláusulas diferentes e não são complementares. A fórmula é satisfatível se e somente se o grafo tem clique de tamanho $m$: um clique escolhe um literal verdadeiro por cláusula, e a ausência de arestas entre complementares garante consistência da atribuição. A construção é polinomial, e a equivalência vale nos dois sentidos — é isso que uma redução precisa demonstrar. Erros comuns</h2> Inverter o sentido da redução.</li> Confundir NP-difícil com "impossível". Instâncias reais podem ser fáceis.</li> Chamar de NP-completo um problema que não está em NP (otimização, por exemplo, é NP-difícil mas não NP-completa).</li> Concluir que NP significa "não polinomial". Significa "não determinístico polinomial".</li> Desistir cedo demais. Resolvedores SAT modernos são extraordinariamente eficazes.</li> </ul> Leituras recomendadas</h2> Sipser, capítulo 7 — P, NP e NP-completude com provas completas.</li> Garey e Johnson — o catálogo clássico de problemas NP-completos; ainda a referência para saber se um problema já foi classificado.</li> Arora e Barak, Computational Complexity: A Modern Approach — o tratamento moderno; rascunho gratuito online.</li> Biere et al., Handbook of Satisfiability — como resolvedores SAT vencem a teoria na prática.</li> </ul> Michael Sipser (2012). Introduction to the Theory of Computation. Cengage Learning. ISBN 9781133187790</a>. Michael R. Garey and David S. Johnson (1979). Computers and Intractability: A Guide to the Theory of NP-Completeness. W. H. Freeman. ISBN 9780716710448</a>. Sanjeev Arora and Boaz Barak (2009). Computational Complexity: A Modern Approach. Cambridge University Press. DOI: 10.1017/cbo9780511804090</a>. Armin Biere and Marijn Heule and Hans van Maaren and Toby Walsh (2009). Handbook of Satisfiability. IOS Press. ISBN 9781586039295</a>. Referências</h2> Michael Sipser (2012). Introduction to the Theory of Computation. Cengage Learning.</li> Michael R. Garey; David S. Johnson (1979). Computers and Intractability: A Guide to the Theory of NP-Completeness. W. H. Freeman.</li> Sanjeev Arora; Boaz Barak (2009). Computational Complexity: A Modern Approach. Cambridge University Press.</li> Armin Biere; Marijn Heule; Hans van Maaren; Toby Walsh (2009). Handbook of Satisfiability. IOS Press.</li> </ol> Máquina de Turing e Decidibilidade 2026-07-26T00:00:00+00:00 Máquina de Turing e Decidibilidade</h1> A máquina de Turing é o modelo que define o que significa "computável". Sua importância não está na eficiência — é um modelo deliberadamente primitivo — mas em delimitar a fronteira do possível. O modelo</h2> Uma fita infinita dividida em células, uma cabeça que lê e escreve, e um controle finito. A cada passo, com base no estado atual e no símbolo lido, a máquina escreve um símbolo, move a cabeça uma célula e muda de estado. Formalmente, uma 7-upla $(Q,\Sigma,\Gamma,\delta,q_0,q_{\text{aceita}},q_{\text{rejeita}})$. Três comportamentos possíveis: aceitar, rejeitar ou não parar. Esta terceira possibilidade é a fonte de tudo o que se segue. Decidível e reconhecível</h2> Decidível (recursiva): existe máquina que sempre para e responde corretamente.</li> Reconhecível (recursivamente enumerável): existe máquina que aceita as cadeias da linguagem, mas pode não parar nas demais.</li> </ul> A diferença é decisiva. Uma linguagem é decidível se e somente se ela e seu complemento são reconhecíveis. Tese de Church-Turing</h2> Tudo que é "efetivamente calculável" pode ser calculado por uma máquina de Turing. Não é um teorema — é uma tese sobre a adequação do modelo à noção intuitiva. A evidência é forte: cálculo lambda, funções recursivas, máquinas de registradores e toda linguagem de programação real definem exatamente a mesma classe de funções. A consequência prática: a escolha da linguagem de programação não muda o que é computável. Só muda a conveniência. O problema da parada</h2> $$\text{PARADA} = {\langle M,w\rangle : M \text{ para com entrada } w}$$ Teorema (Turing, 1936). PARADA é indecidível. A prova é por diagonalização. Suponha que exista $H$ que decida a parada. Construa $D$ que, ao receber $\langle M\rangle$, roda $H(\langle M\rangle,\langle M\rangle)$ e faz o oposto: entra em laço se $H$ diz que para, e para se $H$ diz que não para. Agora pergunte: $D$ para com entrada $\langle D\rangle$? Se para, então $H$ disse que não para — contradição. Se não para, $H$ disse que para — contradição. Logo $H$ não existe. $\blacksquare$ O argumento é o mesmo do paradoxo do barbeiro e da diagonal de Cantor: autorreferência produzindo contradição. Redução</h2> A técnica padrão para provar indecidibilidade de outros problemas: se $A$ é indecidível e $A$ se reduz a $B$, então $B$ é indecidível. A leitura intuitiva: "se eu soubesse resolver $B$, saberia resolver $A$; como não sei resolver $A$, não posso saber resolver $B$". Teorema de Rice</h2> Um resultado devastador e pouco conhecido fora da área: toda propriedade não trivial do comportamento de programas é indecidível. "Não trivial" significa que alguma máquina tem a propriedade e alguma não tem. "Do comportamento" significa que depende da função computada, não do texto do programa. Consequências diretas, todas indecidíveis em geral: Este programa termina?</li> Estes dois programas calculam a mesma coisa?</li> Este programa acessa memória inválida?</li> Este trecho de código é alcançável?</li> Este programa tem vazamento de memória?</li> </ul> Como a prática convive com isso</h2> Este é o ponto mais importante da página. A indecidibilidade não impede ferramentas úteis — impede ferramentas simultaneamente completas, corretas e sempre terminantes. Abre-se mão de uma das três: Aproximação conservadora. Analisadores estáticos e sistemas de tipos rejeitam alguns programas corretos, mas nunca aceitam um errado. Um verificador de tipos que recusa código que funcionaria é o preço da decidibilidade. Incompletude. Ferramentas que podem responder "não sei". A maioria dos analisadores modernos faz isso. Não terminação. Provadores de teoremas que podem rodar indefinidamente, com limite de tempo imposto de fora. Restrição do domínio. Linguagens totais (Coq, Agda) garantem terminação restringindo a recursão ao que se pode provar decrescente. Em troca, não são Turing-completas. Compreender essa negociação evita duas ilusões opostas: esperar que o compilador detecte todos os defeitos, e concluir que análise estática não serve para nada. Contagem: por que quase tudo é incomputável</h2> Um argumento simples e esclarecedor. Programas são cadeias finitas sobre alfabeto finito, logo o conjunto de programas é enumerável. Já o conjunto de funções $\mathbb{N}\to{0,1}$ tem a cardinalidade dos reais — não enumerável. Portanto quase toda função é incomputável. As funções que sabemos calcular são uma parcela infinitesimal do que existe. A surpresa não é que haja problemas indecidíveis; é que tantos problemas úteis sejam decidíveis. Exemplo trabalhado</h2> Por que não é possível escrever um detector universal de laços infinitos? Se para(prog, entrada)</code> existisse, poderíamos escrever: def diagonal(prog): if para(prog, prog): while True: # entra em laço pass else: return # termina</code></pre> Aplicando diagonal</code> a si mesma, ambas as respostas de para</code> levam a contradição. Portanto para</code> não pode existir. Aplicações em computação</h2> Compiladores. Otimizações são sempre aproximações conservadoras; eliminação de código morto detecta só o que consegue provar. Sistemas de tipos. A negociação entre expressividade e decidibilidade define o desenho da linguagem. Verificação formal. Model checking restringe o espaço de estados a finito, tornando o problema decidível. Segurança. Detectar malware por comportamento é indecidível em geral — daí heurísticas e assinaturas. Ferramentas de análise. Falsos positivos são inerentes ao problema, não defeitos de implementação. Erros comuns</h2> Concluir que análise estática é inútil por causa da indecidibilidade.</li> Confundir indecidível com difícil. NP-completo é difícil; indecidível é impossível.</li> Esquecer que instâncias particulares podem ser decidíveis. É o caso geral que não é.</li> Achar que a tese de Church-Turing é teorema.</li> </ul> Leituras recomendadas</h2> Sipser, capítulos 3 a 5 — máquinas de Turing, decidibilidade e redução, com provas acessíveis.</li> Turing, "On Computable Numbers" (1936) — o artigo original, surpreendentemente legível.</li> Hopcroft, Motwani e Ullman, capítulos 8 e 9.</li> Rice (1953) — o teorema que generaliza a indecidibilidade a toda propriedade semântica.</li> </ul> Michael Sipser (2012). Introduction to the Theory of Computation. Cengage Learning. ISBN 9781133187790</a>. John E. Hopcroft and Rajeev Motwani and Jeffrey D. Ullman (2006). Introduction to Automata Theory, Languages, and Computation. Pearson. ISBN 9780321455369</a>. Referências</h2> Michael Sipser (2012). Introduction to the Theory of Computation. Cengage Learning.</li> John E. Hopcroft; Rajeev Motwani; Jeffrey D. Ullman (2006). Introduction to Automata Theory, Languages, and Computation. Pearson.</li> </ol> Árvores 2026-07-26T00:00:00+00:00 Árvores</h1> Árvore é o grafo mais importante da computação. Sistemas de arquivos, índices de banco, árvores sintáticas, hierarquias de herança, o DOM — todos são árvores. A razão é sua propriedade central: caminho único entre quaisquer dois vértices, o que elimina ambiguidade de navegação. Definição e caracterizações</h2> Uma árvore é um grafo conexo e acíclico. Para um grafo $G$ com $n$ vértices, as afirmações abaixo são todas equivalentes: $G$ é conexo e acíclico.</li> $G$ é conexo e tem exatamente $n-1$ arestas.</li> $G$ é acíclico e tem exatamente $n-1$ arestas.</li> Existe caminho único entre quaisquer dois vértices.</li> $G$ é conexo, e remover qualquer aresta o desconecta.</li> $G$ é acíclico, e acrescentar qualquer aresta cria um ciclo.</li> </ol> Ter seis caracterizações equivalentes é o que torna árvores tão fáceis de trabalhar: para provar que algo é árvore, escolha a condição mais conveniente. Um grafo acíclico não necessariamente conexo é uma floresta. Árvores enraizadas</h2> Escolher um vértice como raiz induz orientação: cada vértice ganha um pai (exceto a raiz) e zero ou mais filhos. Termo</th> Significado</th></tr></thead> Folha</td> Vértice sem filhos</td></tr> Nó interno</td> Vértice com pelo menos um filho</td></tr> Profundidade</td> Distância da raiz até o nó</td></tr> Altura</td> Maior profundidade da árvore</td></tr> Ancestral</td> Qualquer nó no caminho até a raiz</td></tr> </tbody></table> Uma árvore binária de altura $h$ tem no máximo $2^{h+1}-1$ nós, logo uma árvore com $n$ nós tem altura mínima $\lceil \log_2(n+1) \rceil - 1$. Essa desigualdade é o que fundamenta as estruturas balanceadas: manter a altura em $\Theta(\log n)$ garante busca logarítmica. Uma árvore de busca degenerada — inserções em ordem crescente sem balanceamento — vira uma lista ligada com altura $n$, e a busca cai para $O(n)$. Percursos</h2> def em_ordem(no): if no: em_ordem(no.esq) visita(no) em_ordem(no.dir)</code></pre>Percurso</th> Ordem</th> Uso típico</th></tr></thead> Pré-ordem</td> raiz, esquerda, direita</td> Copiar a árvore, serializar</td></tr> Em ordem</td> esquerda, raiz, direita</td> Listar em ordem crescente numa BST</td></tr> Pós-ordem</td> esquerda, direita, raiz</td> Liberar memória, avaliar expressão</td></tr> Em largura</td> por nível</td> Achar o nó mais raso, imprimir níveis</td></tr> </tbody></table> Numa árvore de expressão, pré-ordem produz notação prefixa (polonesa) e pós-ordem produz notação pós-fixa (polonesa reversa) — que é exatamente o que uma máquina de pilha executa. É por isso que compiladores geram código percorrendo a árvore sintática em pós-ordem. Árvore geradora mínima</h2> Dado um grafo conexo ponderado, a árvore geradora mínima (AGM) é a árvore que conecta todos os vértices com peso total mínimo. Kruskal. Ordene as arestas por peso e acrescente cada uma que não forme ciclo, usando union-find para o teste. Custo $O(E \log E)$. Prim. Cresça a árvore a partir de um vértice, sempre pegando a aresta mais leve que sai do conjunto atual. Com heap de Fibonacci, $O(E + V \log V)$. Ambos são algoritmos gulosos, e ambos funcionam pela propriedade do corte: para qualquer partição dos vértices em dois conjuntos, a aresta mais leve que cruza a partição pertence a alguma AGM. Aplicações: projeto de redes com custo mínimo de cabeamento, agrupamento hierárquico (cortar as $k-1$ arestas mais pesadas da AGM dá $k$ grupos) e aproximações para o caixeiro viajante. Estruturas de dados derivadas</h2> Árvore binária de busca. Invariante: tudo à esquerda é menor, tudo à direita é maior. Busca, inserção e remoção em $O(h)$. AVL e rubro-negra. Mantêm $h = O(\log n)$ por rotações. AVL é mais rigidamente balanceada (busca ligeiramente mais rápida); rubro-negra faz menos rotações (inserção e remoção mais rápidas). std::map</code> do C++ e TreeMap</code> do Java usam rubro-negra. Árvore B e B+. Alta aridade para minimizar acessos a disco. Um nó ocupa uma página, e com aridade de algumas centenas a altura fica em 3 ou 4 mesmo com bilhões de chaves. É a estrutura de praticamente todo índice de banco de dados e de vários sistemas de arquivos. Heap binário. Árvore quase completa com a propriedade de que o pai domina os filhos. Armazenado em vetor, sem ponteiros: os filhos de $i$ são $2i+1$ e $2i+2$. Base de filas de prioridade e do heapsort. Trie. Árvore indexada por prefixos de cadeia. Busca em $O(m)$ com $m$ o comprimento da chave, independente do número de chaves armazenadas. Árvore de Merkle. Cada nó guarda o resumo criptográfico dos filhos. Permite verificar a integridade de um item com $O(\log n)$ resumos — a base de Git, blockchains e sistemas de arquivos verificáveis. Exemplo trabalhado</h2> Uma árvore binária completa de altura $3$ tem quantos nós e quantas folhas? Nós: $2^{3+1} - 1 = 15$. Folhas: $2^3 = 8$. Nós internos: $15 - 8 = 7$ — confirmando que numa árvore binária completa o número de folhas é o de internos mais um. Erros comuns</h2> Não balancear uma árvore de busca e obter $O(n)$ em dados ordenados.</li> Confundir altura com profundidade. Altura é da árvore; profundidade é de um nó.</li> Recursão profunda estourando a pilha em árvores degeneradas.</li> Modificar a chave de um nó já inserido, quebrando o invariante da estrutura.</li> Usar árvore onde uma tabela hash serve. Se a ordem não importa, hash é mais rápido.</li> </ul> Leituras recomendadas</h2> Cormen et al., capítulos 12 e 13 — árvores de busca e rubro-negras, com todas as provas de balanceamento.</li> Knuth, TAOCP volume 3 — o tratamento clássico e exaustivo de árvores de busca e ordenação.</li> Documentação do PostgreSQL sobre índices B-tree — como a teoria aparece num sistema real de produção.</li> Diestel, capítulo 1 — as caracterizações equivalentes de árvore, com provas.</li> </ul> Thomas H. Cormen and Charles E. Leiserson and Ronald L. Rivest and Clifford Stein (2009). Introduction to Algorithms. MIT Press. ISBN 9780262533058</a>. Donald E. Knuth (1998). The Art of Computer Programming, Volume 3: Sorting and Searching. Addison-Wesley. Página oficial</a>. Reinhard Diestel (2017). Graph Theory. Springer. DOI: 10.1007/978-3-662-53622-3</a>. Referências</h2> Thomas H. Cormen; Charles E. Leiserson; Ronald L. Rivest; Clifford Stein (2009). Introduction to Algorithms. MIT Press.</li> Donald E. Knuth (1998). The Art of Computer Programming, Volume 3: Sorting and Searching. Addison-Wesley.</li> Reinhard Diestel (2017). Graph Theory. Springer.</li> </ol> Caminhos Mínimos 2026-07-26T00:00:00+00:00 Caminhos Mínimos</h1> Encontrar o caminho de menor custo entre dois pontos é um dos problemas mais aplicados da computação. A escolha do algoritmo depende de três perguntas: os pesos podem ser negativos? Preciso de uma origem ou de todos os pares? O grafo é denso ou esparso? O problema</h2> Dado $G = (V, E)$ com pesos $w: E \to \mathbb{R}$, o custo de um caminho é a soma dos pesos das arestas. Busca-se o caminho de custo mínimo. Três variantes: Origem única: de um vértice a todos.</li> Todos os pares: entre quaisquer dois.</li> Par único: entre dois vértices dados. Na prática resolve-se com o algoritmo de origem única, possivelmente com parada antecipada.</li> </ul> Se houver ciclo de peso negativo alcançável, não existe caminho mínimo: dar voltas no ciclo reduz o custo indefinidamente. Detectar esses ciclos é parte do problema. A operação de relaxamento</h2> Todos os algoritmos compartilham uma única operação. Mantendo uma estimativa $d[v]$ do custo até $v$: def relaxa(u, v, w, d, pai): if d[u] + w[u][v] < d[v]: d[v] = d[u] + w[u][v] pai[v] = u</code></pre> Os algoritmos diferem apenas na ordem em que relaxam as arestas. Entender isso simplifica muito: não são três ideias diferentes, é uma ideia com três estratégias de ordenação. Dijkstra</h2> Estratégia gulosa: sempre expandir o vértice não visitado de menor distância estimada. import heapq def dijkstra(grafo, origem): dist = {v: float('inf') for v in grafo} dist[origem] = 0 fila = [(0, origem)] visto = set() while fila: d, u = heapq.heappop(fila) if u in visto: continue visto.add(u) for v, peso in grafo[u]: if dist[u] + peso < dist[v]: dist[v] = dist[u] + peso heapq.heappush(fila, (dist[v], v)) return dist</code></pre> Exige pesos não negativos. A prova de correção depende de que, ao extrair o vértice de menor estimativa, essa estimativa já seja definitiva — e um peso negativo mais adiante poderia reduzi-la depois, quebrando o argumento. Complexidade: $O((V+E)\log V)$ com heap binário; $O(E + V\log V)$ com heap de Fibonacci. Bellman-Ford</h2> Relaxa todas as arestas $|V|-1$ vezes. def bellman_ford(vertices, arestas, origem): dist = {v: float('inf') for v in vertices} dist[origem] = 0 for _ in range(len(vertices) - 1): for u, v, peso in arestas: if dist[u] + peso < dist[v]: dist[v] = dist[u] + peso # uma passada extra detecta ciclo negativo for u, v, peso in arestas: if dist[u] + peso < dist[v]: raise ValueError('ciclo de peso negativo alcançável') return dist</code></pre> Aceita pesos negativos e detecta ciclos negativos. O número de iterações vem do fato de que um caminho mínimo tem no máximo $|V|-1$ arestas; se ainda houver melhoria na passada extra, existe ciclo negativo. Complexidade: $O(VE)$ — mais lento, em troca de generalidade. Floyd-Warshall</h2> Programação dinâmica para todos os pares: def floyd_warshall(dist, n): for k in range(n): for i in range(n): for j in range(n): if dist[i][k] + dist[k][j] < dist[i][j]: dist[i][j] = dist[i][k] + dist[k][j] return dist</code></pre> A ideia: $k$ percorre os vértices permitidos como intermediários. Após a iteração $k$, dist[i][j]</code> é o mínimo usando apenas ${0,\dots,k}$ como intermediários. Complexidade $\Theta(V^3)$, espaço $\Theta(V^2)$. Vale a pena em grafos densos e pequenos. Valor negativo na diagonal indica ciclo negativo. Comparação</h2> Algoritmo</th> Alcance</th> Pesos negativos</th> Complexidade</th> Quando usar</th></tr></thead> BFS</td> Origem única</td> Sem pesos</td> $O(V+E)$</td> Grafo não ponderado</td></tr> Dijkstra</td> Origem única</td> Não</td> $O(E \log V)$</td> Padrão para pesos positivos</td></tr> Bellman-Ford</td> Origem única</td> Sim</td> $O(VE)$</td> Há pesos negativos</td></tr> Floyd-Warshall</td> Todos os pares</td> Sim</td> $O(V^3)$</td> Grafo denso e pequeno</td></tr> A*</td> Par único</td> Não</td> Depende da heurística</td> Há boa estimativa de distância</td></tr> </tbody></table> Se o grafo não é ponderado, use BFS: ela resolve em tempo linear o que Dijkstra resolveria com um fator logarítmico a mais. A*: Dijkstra com heurística</h2> A* ordena a fila por $f(v) = d[v] + h(v)$, com $h$ uma estimativa do custo restante até o destino. Para garantir otimalidade, $h$ precisa ser admissível (nunca superestimar) e, para a versão com conjunto fechado, consistente ($h(u) \le w(u,v) + h(v)$). Com $h \equiv 0$, A* é exatamente Dijkstra. Quanto melhor a heurística, menos nós são expandidos. Em mapas, a distância em linha reta é admissível e reduz drasticamente a exploração — é o que torna viável o roteamento em grafos rodoviários continentais. Exemplo trabalhado</h2> Grafo dirigido: $A \to B$ (peso 4), $A \to C$ (2), $C \to B$ (1), $B \to D$ (5), $C \to D$ (8). Dijkstra a partir de $A$: Extrai $A$ ($d=0$). Relaxa: $d[B]=4$, $d[C]=2$.</li> Extrai $C$ ($d=2$, menor). Relaxa: $d[B] = \min(4, 2+1) = 3$; $d[D] = 10$.</li> Extrai $B$ ($d=3$). Relaxa: $d[D] = \min(10, 3+5) = 8$.</li> Extrai $D$ ($d=8$).</li> </ol> Resultado: $A \to C \to B \to D$ com custo $8$. Note que o caminho ótimo passa por $C$ mesmo a aresta direta $A \to B$ existindo — é exatamente o tipo de situação que o relaxamento captura. Aplicações em computação</h2> Roteamento. OSPF usa Dijkstra; RIP e BGP usam variantes de vetor de distância aparentadas com Bellman-Ford. Navegação. Mapas usam A* com pré-processamento (rotulagem de atalhos, hierarquias de contração) para responder em milissegundos sobre grafos com milhões de vértices. Arbitragem. Um ciclo de peso negativo sobre $-\log(\text{taxa de câmbio})$ é uma oportunidade de arbitragem — Bellman-Ford detecta. Jogos. Busca de caminho de unidades em mapa de grade, tipicamente A* com heurística de Manhattan ou octil. Escalonamento. Restrições de diferença ($x_j - x_i \le c$) formam um sistema resolvido por caminhos mínimos. Erros comuns</h2> Usar Dijkstra com pesos negativos. O resultado pode estar errado sem nenhum aviso.</li> Esquecer a passada extra do Bellman-Ford, perdendo a detecção de ciclo negativo.</li> Não verificar se o vértice já foi visitado ao desempilhar em Dijkstra, degradando o desempenho.</li> Heurística inadmissível em A*, que produz caminho subótimo silenciosamente.</li> Floyd-Warshall com $V$ grande. $V = 10^4$ já significa $10^{12}$ operações.</li> </ul> Leituras recomendadas</h2> Cormen et al., capítulos 24 e 25 — caminhos mínimos com provas de correção completas.</li> Kleinberg e Tardos, capítulo 6 — Bellman-Ford apresentado como programação dinâmica.</li> Documentação do NetworkX e do igraph — implementações de referência e escolha de algoritmo por caso.</li> Artigos sobre hierarquias de contração — como o roteamento em mapas reais fica rápido o suficiente.</li> </ul> Thomas H. Cormen and Charles E. Leiserson and Ronald L. Rivest and Clifford Stein (2009). Introduction to Algorithms. MIT Press. ISBN 9780262533058</a>. Jon Kleinberg and Eva Tardos (2005). Algorithm Design. Pearson. ISBN 9780321295354</a>. Referências</h2> Thomas H. Cormen; Charles E. Leiserson; Ronald L. Rivest; Clifford Stein (2009). Introduction to Algorithms. MIT Press.</li> Jon Kleinberg; Eva Tardos (2005). Algorithm Design. Pearson.</li> </ol> Coloração de Grafos 2026-07-26T00:00:00+00:00 Coloração de Grafos</h1> Colorir um grafo é atribuir rótulos aos vértices de forma que vértices adjacentes recebam rótulos distintos. É a formulação abstrata de todo problema de alocação sob conflito: dois recursos que não podem coexistir viram vértices adjacentes. Definições</h2> Uma coloração própria com $k$ cores é uma função $c: V \to {1,\dots,k}$ tal que $c(u) \ne c(v)$ para toda aresta ${u,v}$. O número cromático $\chi(G)$ é o menor $k$ para o qual existe coloração própria. Determinar $\chi(G)$ é NP-difícil; até decidir se $\chi(G) \le 3$ é NP-completo. Na prática usam-se heurísticas e limites. Limites</h2> $$\chi(G) \le \Delta(G) + 1$$ com $\Delta(G)$ o grau máximo. A prova é o próprio algoritmo guloso: ao colorir um vértice, seus vizinhos ocupam no máximo $\Delta$ cores, então sempre sobra uma. O teorema de Brooks refina: para grafo conexo que não seja completo nem ciclo ímpar, $\chi(G) \le \Delta(G)$. Por baixo, $\chi(G) \ge \omega(G)$, o tamanho da maior clique — um conjunto de vértices mutuamente adjacentes precisa de uma cor cada. Casos especiais</h2> Grafo</th> $\chi$</th></tr></thead> Completo $K_n$</td> $n$</td></tr> Bipartido (com aresta)</td> $2$</td></tr> Ciclo par</td> $2$</td></tr> Ciclo ímpar</td> $3$</td></tr> Árvore (com aresta)</td> $2$</td></tr> Planar</td> $\le 4$</td></tr> </tbody></table> $\chi(G) \le 2$ equivale a ser bipartido, o que se testa em tempo linear com BFS de duas cores. A partir de 3 cores o problema já é NP-completo — um salto de dificuldade abrupto. O teorema das quatro cores (Appel e Haken, 1976) afirma que todo grafo planar é 4-colorível. Foi o primeiro teorema importante cuja prova dependeu essencialmente de verificação por computador, o que gerou um debate duradouro sobre o que conta como demonstração matemática. Algoritmo guloso</h2> def coloracao_gulosa(grafo, ordem): cor = {} for v in ordem: usadas = {cor[u] for u in grafo[v] if u in cor} c = 0 while c in usadas: c += 1 cor[v] = c return cor</code></pre> O guloso usa no máximo $\Delta + 1$ cores, mas o resultado depende fortemente da ordem. Existe sempre uma ordem que produz a coloração ótima — e encontrá-la é o problema difícil. Heurísticas de ordenação que funcionam bem: Welsh-Powell: por grau decrescente. Trata primeiro os vértices mais restritos.</li> DSATUR: a cada passo escolhe o vértice com maior número de cores distintas na vizinhança. Costuma dar resultados bem melhores e é ótima em grafos bipartidos.</li> Ordem de eliminação perfeita: em grafos cordais, produz o ótimo.</li> </ul> Alocação de registradores</h2> Esta é a aplicação canônica em compiladores, e vale entender em detalhe. Cada variável do programa vira um vértice. Duas variáveis são adjacentes quando estão vivas ao mesmo tempo — o que forma o grafo de interferência. As cores são os registradores da máquina. Se $\chi(G) \le k$, com $k$ o número de registradores, todas as variáveis cabem em registradores. Caso contrário, alguma precisa ir para memória — o spill, cuja escolha o compilador faz por heurística de custo. O algoritmo clássico de Chaitin remove repetidamente vértices de grau menor que $k$ (que sempre poderão ser coloridos depois), empilhando-os; se travar, escolhe um candidato a spill. A coloração é feita ao desempilhar. É uma tradução perfeita: um problema aparentemente de engenharia é exatamente um problema de teoria dos grafos, e usar a teoria dá tanto o algoritmo quanto o limite de qualidade. Outras aplicações</h2> Escalonamento de provas. Disciplinas com alunos em comum viram vértices adjacentes; as cores são horários. O número cromático é a menor quantidade de horários necessária. Alocação de frequências. Antenas próximas interferem; frequências são cores. É o problema original que motivou boa parte da teoria. Sudoku. Um sudoku é uma coloração de grafo com 9 cores, em que células da mesma linha, coluna ou bloco são adjacentes. Paralelismo. Tarefas que disputam o mesmo recurso não podem rodar juntas; cores são fatias de tempo. Compilação de consultas. Alocação de buffers em planos de execução usa a mesma modelagem. Exemplo trabalhado</h2> Considere o ciclo $C_5$ (cinco vértices em círculo). Como é ciclo ímpar, $\chi(C_5) = 3$. Tentando com duas cores, a alternância percorre o ciclo e o quinto vértice acaba adjacente a dois vértices que já ocupam as duas cores. O grau máximo é $2$, e o teorema de Brooks não se aplica justamente porque ciclos ímpares são a exceção — coerente com $\chi = 3 = \Delta + 1$. Erros comuns</h2> Supor que o guloso dá o ótimo. Ele dá um limite superior, e a qualidade depende da ordem.</li> Confundir $\chi(G)$ com $\Delta(G)$. O grau máximo é limite, não valor.</li> Achar que 2 cores é fácil e 3 é só um pouco mais difícil. A fronteira entre P e NP-completo está exatamente aí.</li> Ignorar a estrutura do grafo. Grafos cordais, de intervalo e planares têm algoritmos eficientes que não valem no caso geral.</li> </ul> Leituras recomendadas</h2> Diestel, capítulo 5 — coloração com as provas dos teoremas de Brooks e Vizing.</li> Documentação do LLVM sobre alocação de registradores — a teoria aplicada num compilador de produção.</li> Garey e Johnson — a referência sobre NP-completude, com a prova para 3-coloração.</li> West, capítulo 5 — muitos exercícios de coloração.</li> </ul> Reinhard Diestel (2017). Graph Theory. Springer. DOI: 10.1007/978-3-662-53622-3</a>. Michael R. Garey and David S. Johnson (1979). Computers and Intractability: A Guide to the Theory of NP-Completeness. W. H. Freeman. ISBN 9780716710448</a>. Douglas B. West (2001). Introduction to Graph Theory. Prentice Hall. Página oficial</a>. Referências</h2> Reinhard Diestel (2017). Graph Theory. Springer.</li> Michael R. Garey; David S. Johnson (1979). Computers and Intractability: A Guide to the Theory of NP-Completeness. W. H. Freeman.</li> Douglas B. West (2001). Introduction to Graph Theory. Prentice Hall.</li> </ol> Combinatória 2026-07-26T00:00:00+00:00 Combinatória</h1> Combinatória é a arte de contar sem enumerar. Em computação ela responde às perguntas que decidem viabilidade: quantas configurações existem, qual o tamanho do espaço de busca, qual a probabilidade de colisão numa tabela hash. Os dois princípios</h2> Princípio aditivo. Se uma escolha pode ser feita de $m$ formas ou de $n$ formas, e as opções são disjuntas, há $m + n$ possibilidades. Princípio multiplicativo. Se uma tarefa se decompõe em etapas independentes com $m$ e $n$ opções, há $m \cdot n$ resultados. Praticamente toda contagem se reduz a combinar esses dois. A dificuldade quase nunca está na aritmética; está em decidir se as escolhas são disjuntas (soma) ou sequenciais (produto), e em não contar a mesma coisa duas vezes. Permutações, arranjos e combinações</h2> Conceito</th> Fórmula</th> Pergunta que responde</th></tr></thead> Permutação de $n$</td> $n!$</td> De quantas formas ordenar $n$ objetos?</td></tr> Arranjo $A(n,k)$</td> $\dfrac{n!}{(n-k)!}$</td> Escolher $k$ de $n$, com ordem</td></tr> Combinação $\binom{n}{k}$</td> $\dfrac{n!}{k!(n-k)!}$</td> Escolher $k$ de $n$, sem ordem</td></tr> </tbody></table> A relação entre arranjo e combinação é a chave: cada combinação de $k$ elementos pode ser ordenada de $k!$ formas, logo $A(n,k) = \binom{n}{k} \cdot k!$. A pergunta que resolve quase todo exercício é simples: a ordem importa? Uma senha de 4 dígitos distintos é arranjo; uma mão de 5 cartas é combinação. Propriedades do coeficiente binomial</h2> $$\binom{n}{k} = \binom{n}{n-k} \qquad \text{(escolher }k\text{ é o mesmo que descartar }n-k\text{)}$$ $$\binom{n}{k} = \binom{n-1}{k-1} + \binom{n-1}{k} \qquad \text{(relação de Pascal)}$$ $$\sum_{k=0}^{n} \binom{n}{k} = 2^n \qquad \text{(total de subconjuntos)}$$ A relação de Pascal tem interpretação direta: fixe um elemento; ou ele está no subconjunto (e faltam $k-1$ entre os $n-1$ restantes) ou não está (e faltam $k$ entre $n-1$). É também a recorrência que gera o triângulo de Pascal e a base da implementação por programação dinâmica. def binomial(n, k): # calcula sem passar por n! — evita estouro e é mais rápido if k > n - k: k = n - k r = 1 for i in range(k): r = r * (n - i) // (i + 1) return r</code></pre> Calcular $\binom{n}{k}$ como $n!/(k!(n-k)!)$ é um erro prático: $n!$ estoura muito antes do resultado. A forma iterativa acima mantém os valores intermediários pequenos e a divisão sempre exata. Binômio de Newton</h2> $$(x + y)^n = \sum_{k=0}^{n} \binom{n}{k} x^{n-k} y^k$$ O coeficiente de $x^{n-k}y^k$ conta de quantas formas escolher $k$ fatores que contribuem com $y$. Fazendo $x = y = 1$ recupera-se $\sum_k \binom{n}{k} = 2^n$. Combinações com repetição</h2> Para escolher $k$ elementos de $n$ tipos, com repetição permitida e sem ordem: $$\left(!!\binom{n}{k}!!\right) = \binom{n + k - 1}{k}$$ A demonstração é o argumento de estrelas e barras: represente a escolha por $k$ estrelas separadas por $n-1$ barras; cada arranjo dos $n+k-1$ símbolos determina uma escolha. É a fórmula que conta soluções inteiras não negativas de $x_1 + \cdots + x_n = k$ — que aparece em alocação de recursos e em análise de distribuição de carga. Princípio de inclusão-exclusão</h2> $$\left|\bigcup_{i=1}^{n} A_i\right| = \sum |A_i| - \sum |A_i \cap A_j| + \sum |A_i \cap A_j \cap A_k| - \cdots$$ Corrige a contagem dupla alternando sinais. Aplicação clássica: contar desarranjos — permutações sem ponto fixo: $$D_n = n! \sum_{k=0}^{n} \frac{(-1)^k}{k!} \approx \frac{n!}{e}$$ Ou seja, cerca de $37%$ das permutações não deixam nenhum elemento no lugar — um fato que surpreende e que independe de $n$. Exemplo trabalhado: o paradoxo do aniversário</h2> Qual a probabilidade de que, entre $k$ pessoas, duas façam aniversário no mesmo dia? É mais fácil contar o complemento. O número de formas de $k$ pessoas terem datas todas distintas é $A(365, k)$, e o total de configurações é $365^k$: $$P(\text{todas distintas}) = \frac{365 \cdot 364 \cdots (365-k+1)}{365^k}$$ Para $k = 23$ isso dá aproximadamente $0{,}493$ — logo a probabilidade de colisão passa de $50%$ com apenas 23 pessoas. Este resultado é o ataque do aniversário em criptografia: para uma função de resumo de $n$ bits, espera-se encontrar colisão após cerca de $2^{n/2}$ tentativas, e não $2^n$. É por isso que resistência a colisão de 128 bits exige um resumo de 256 bits. Aplicações em computação</h2> Tabelas hash. A análise de colisões é combinatória de bolas em urnas. Com $n$ chaves em $m$ posições, o comprimento máximo esperado de uma lista é $\Theta(\log n / \log\log n)$. Espaço de busca. Contar configurações decide se busca exaustiva é viável. Um problema com $2^{40}$ estados é tratável; com $2^{80}$, não. Complexidade de senhas. Uma senha de comprimento $L$ sobre alfabeto de tamanho $A$ tem $A^L$ possibilidades — a base de todo cálculo de entropia. Aprendizado de máquina. A contagem de hipóteses limita a capacidade de generalização; é o ingrediente combinatório por trás da dimensão VC. Testes. Cobertura de pares (pairwise testing) usa desenhos combinatórios para cobrir todas as interações de dois parâmetros com poucas execuções. Erros comuns</h2> Confundir arranjo com combinação. Pergunte sempre se a ordem importa.</li> Contar duas vezes ao aplicar o princípio aditivo a casos não disjuntos — é para isso que existe a inclusão-exclusão.</li> Calcular fatoriais grandes desnecessariamente.</li> Esquecer que escolhas podem não ser independentes. O princípio multiplicativo exige que o número de opções de cada etapa não dependa das escolhas anteriores.</li> </ul> Leituras recomendadas</h2> Rosen, capítulos de contagem — muitos exercícios e aplicações diretas em computação.</li> Graham, Knuth e Patashnik, capítulo 5 — coeficientes binomiais em profundidade; é a referência definitiva sobre identidades binomiais.</li> Knuth, TAOCP volume 4A — geração combinatória: como enumerar permutações, combinações e partições eficientemente.</li> </ul> Kenneth H. Rosen (2019). Discrete Mathematics and Its Applications. McGraw-Hill. ISBN 9781259676512</a>. Ronald L. Graham and Donald E. Knuth and Oren Patashnik (1994). Concrete Mathematics: A Foundation for Computer Science. Addison-Wesley. ISBN 9780134389967</a>. Referências</h2> Kenneth H. Rosen (2019). Discrete Mathematics and Its Applications. McGraw-Hill.</li> Ronald L. Graham; Donald E. Knuth; Oren Patashnik (1994). Concrete Mathematics: A Foundation for Computer Science. Addison-Wesley.</li> </ol> Teoria dos Conjuntos 2026-07-26T00:00:00+00:00 Teoria dos Conjuntos</h1> Conjunto é o objeto mais básico da matemática — quase tudo se define a partir dele. Em computação a correspondência é direta: set</code> em Python, HashSet</code> em Java, tabelas em bancos relacionais e tipos algébricos são todos realizações da mesma ideia. Definições</h2> Um conjunto é uma coleção não ordenada de elementos distintos. Escrevemos $x \in A$ para "$x$ pertence a $A$". Duas consequências práticas da definição: não há ordem (${1,2} = {2,1}$) e não há repetição (${1,1,2} = {1,2}$). Estruturas que preservam ordem são sequências; as que permitem repetição são multiconjuntos. Notações comuns: $$A = {1, 2, 3} \qquad B = {x \in \mathbb{Z} : x > 0 \wedge x \text{ é par}}$$ A segunda é a notação por compreensão, e é exatamente a mesma ideia da list comprehension em Python. Relações entre conjuntos</h2> $A \subseteq B$ (subconjunto): todo elemento de $A$ está em $B$.</li> $A \subsetneq B$ (subconjunto próprio): $A \subseteq B$ e $A \ne B$.</li> $A = B$ se e somente se $A \subseteq B$ e $B \subseteq A$ — a técnica padrão para provar igualdade de conjuntos.</li> </ul> O conjunto vazio $\emptyset$ é subconjunto de qualquer conjunto, inclusive de si mesmo. Operações</h2> Operação</th> Símbolo</th> Definição</th></tr></thead> União</td> $A \cup B$</td> ${x : x \in A \vee x \in B}$</td></tr> Interseção</td> $A \cap B$</td> ${x : x \in A \wedge x \in B}$</td></tr> Diferença</td> $A \setminus B$</td> ${x : x \in A \wedge x \notin B}$</td></tr> Diferença simétrica</td> $A \triangle B$</td> $(A \setminus B) \cup (B \setminus A)$</td></tr> Complemento</td> $\overline{A}$</td> $U \setminus A$, com $U$ o universo</td></tr> </tbody></table> Cada operação de conjuntos corresponde a um conectivo lógico — união a $\vee$, interseção a $\wedge$, complemento a $\neg$. É por isso que as leis são as mesmas: $$\overline{A \cup B} = \overline{A} \cap \overline{B} \qquad \overline{A \cap B} = \overline{A} \cup \overline{B}$$ Produto cartesiano</h2> $$A \times B = {(a, b) : a \in A, b \in B}$$ Aqui a ordem importa: $(1,2) \ne (2,1)$. E $|A \times B| = |A| \cdot |B|$. O produto cartesiano é o fundamento do modelo relacional: uma tabela com colunas de tipos $T_1, \dots, T_n$ é um subconjunto de $T_1 \times \cdots \times T_n$. O CROSS JOIN</code> do SQL é literalmente esta operação, e todo outro JOIN</code> é um subconjunto dele filtrado por um predicado. Conjunto potência</h2> O conjunto potência $\mathcal{P}(A)$ é o conjunto de todos os subconjuntos de $A$: $$\mathcal{P}({1,2}) = {\emptyset, {1}, {2}, {1,2}}$$ $$|\mathcal{P}(A)| = 2^{|A|}$$ A justificativa da fórmula é uma bijeção útil: cada subconjunto corresponde a uma escolha binária por elemento — incluir ou não. É exatamente a representação por máscara de bits, em que um conjunto de até 64 elementos cabe num inteiro e as operações viram instruções de uma palavra: mascara_a | mascara_b // união mascara_a & mascara_b // interseção mascara_a & ~mascara_b // diferença mascara_a ^ mascara_b // diferença simétrica</code></pre> O crescimento $2^n$ também é o motivo de "enumerar todos os subconjuntos" ser inviável além de umas poucas dezenas de elementos. Cardinalidade</h2> Para conjuntos finitos, $|A|$ é a contagem de elementos. O princípio da inclusão-exclusão corrige a contagem dupla: $$|A \cup B| = |A| + |B| - |A \cap B|$$ $$|A \cup B \cup C| = |A| + |B| + |C| - |A \cap B| - |A \cap C| - |B \cap C| + |A \cap B \cap C|$$ Para conjuntos infinitos, cardinalidade se define por bijeção. $\mathbb{N}$, $\mathbb{Z}$ e $\mathbb{Q}$ têm a mesma cardinalidade — são enumeráveis. $\mathbb{R}$ não é, pelo argumento diagonal de Cantor. Esse resultado tem consequência direta em computação: o conjunto de programas é enumerável (cada um é uma cadeia finita), mas o conjunto de funções $\mathbb{N} \to {0,1}$ não é. Logo existem funções que nenhum programa computa — e a indecidibilidade do problema da parada é uma instância concreta disso. Exemplo trabalhado</h2> Numa turma de 100 alunos, 60 cursam álgebra, 45 cursam análise e 25 cursam ambas. Quantos não cursam nenhuma? $$|A \cup B| = 60 + 45 - 25 = 80$$ Logo $100 - 80 = 20$ alunos não cursam nenhuma das duas. Aplicações em computação</h2> Estruturas de dados. Tabelas hash e árvores de busca implementam conjuntos com pertinência em $O(1)$ ou $O(\log n)$. A escolha entre elas é a escolha entre pertinência rápida e iteração ordenada. Bancos de dados. UNION</code>, INTERSECT</code> e EXCEPT</code> são as operações de conjunto diretamente. A álgebra relacional inteira é construída sobre elas. Filtros de Bloom. Uma estrutura probabilística que responde pertinência com falsos positivos mas nunca falsos negativos, trocando exatidão por espaço. Análise estática. Compiladores propagam conjuntos de variáveis vivas ou definições alcançáveis pelo grafo de fluxo, usando união e interseção a cada nó. Tipos. Tipos soma são uniões disjuntas; tipos produto são produtos cartesianos. O sistema de tipos é uma teoria de conjuntos aplicada. Erros comuns</h2> Confundir $\in$ com $\subseteq$. ${1} \subseteq {1,2}$ é verdadeiro; ${1} \in {1,2}$ é falso.</li> Esquecer que $\emptyset \ne {\emptyset}$. O primeiro é vazio; o segundo tem um elemento.</li> Somar cardinalidades sem descontar a interseção.</li> Supor ordem em conjuntos. A ordem de iteração de um set</code> não é garantida; se ela importa, a estrutura certa é outra.</li> </ul> Paul R. Halmos (1974). Naive Set Theory. Springer. DOI: 10.1007/978-1-4757-1645-0</a>. Kenneth H. Rosen (2019). Discrete Mathematics and Its Applications. McGraw-Hill. ISBN 9781259676512</a>. Referências</h2> Paul R. Halmos (1974). Naive Set Theory. Springer.</li> Kenneth H. Rosen (2019). Discrete Mathematics and Its Applications. McGraw-Hill.</li> </ol> Funções 2026-07-26T00:00:00+00:00 Funções</h1> Função é o conceito que atravessa toda a matemática e toda a computação. A definição matemática é mais restrita do que "função" em programação, e a diferença é justamente o que explica vários comportamentos do dia a dia. Definição</h2> Uma função $f: A \to B$ associa a cada elemento de $A$ exatamente um elemento de $B$. O conjunto $A$ é o domínio, $B$ é o contradomínio, e $$\operatorname{Im}(f) = {f(a) : a \in A} \subseteq B$$ é a imagem. Duas exigências merecem destaque, porque é onde a noção matemática difere da computacional: Totalidade — todo elemento do domínio tem imagem. Uma "função" que lança exceção para certas entradas é, matematicamente, uma função parcial.</li> Determinismo — a mesma entrada sempre produz a mesma saída. random()</code> e now()</code> não são funções nesse sentido.</li> </ol> Programação funcional chama de pura exatamente a função que satisfaz as duas condições. É por isso que funções puras podem ser memoizadas, reordenadas e paralelizadas com segurança, e impuras não. Injetividade, sobrejetividade, bijeção</h2> Propriedade</th> Definição</th> Significado</th></tr></thead> Injetora</td> $f(a_1) = f(a_2) \to a_1 = a_2$</td> Não colide: entradas distintas, saídas distintas</td></tr> Sobrejetora</td> $\forall b \in B, \exists a, f(a) = b$</td> Cobre todo o contradomínio</td></tr> Bijetora</td> Injetora e sobrejetora</td> Correspondência perfeita</td></tr> </tbody></table> Só funções bijetoras têm inversa $f^{-1}: B \to A$ com $f^{-1}(f(a)) = a$. Um resultado de contagem que decorre diretamente: se $|A| > |B|$, nenhuma função $A \to B$ pode ser injetora. Este é o princípio da casa dos pombos, e é o que garante que toda função de hash colide quando o espaço de entrada é maior que o de saída. Composição</h2> $$(g \circ f)(x) = g(f(x))$$ A composição é associativa mas não comutativa. Ela preserva as propriedades acima: composição de injetoras é injetora, de sobrejetoras é sobrejetora, de bijeções é bijeção. Em código, composição é o encadeamento de transformações — map(g, map(f, xs))</code> equivale a map(g ∘ f, xs)</code>, e é essa igualdade que permite a um compilador ou a uma biblioteca de streams fundir dois laços num só. Exemplo trabalhado</h2> Classificar $f: \mathbb{Z} \to \mathbb{Z}$, $f(x) = 2x$. Injetora? Sim: $2a = 2b$ implica $a = b$.</li> Sobrejetora? Não: nenhum inteiro tem imagem $3$.</li> Logo não é bijetora e não tem inversa em $\mathbb{Z}$.</li> </ul> Agora mude o contradomínio para o conjunto dos pares. A mesma regra passa a ser bijeção, com inversa $x \mapsto x/2$. A lição é importante: injetividade e sobrejetividade dependem dos conjuntos escolhidos, não só da fórmula. É o mesmo motivo pelo qual mudar o tipo de retorno de uma função muda o que se pode garantir sobre ela. Funções em computação</h2> Hashing. $h: U \to {0, \dots, m-1}$ com $|U| \gg m$. Nunca injetora, logo colisões são inevitáveis e toda tabela hash precisa de estratégia de resolução. Uma boa função de hash distribui a imagem uniformemente; ela não evita colisões, apenas as espalha. Criptografia. Uma função de mão única é fácil de calcular e difícil de inverter, mesmo sendo matematicamente inversível. Já uma cifra é uma bijeção — do contrário decifrar seria ambíguo. Funções de resumo criptográfico não são bijeções, e é aí que entra a resistência a colisões. Índices de banco. Um índice único impõe injetividade sobre a coluna. Uma chave estrangeira impõe que a imagem esteja contida no conjunto de chaves da tabela referenciada. Sistemas de tipos. A assinatura A -> B</code> é literalmente uma função. Currificação é a bijeção entre $C^{A \times B}$ e $(C^B)^A$ — isto é, entre funções de dois argumentos e funções que devolvem funções. Memoização. Só é correta para funções puras. Guardar resultado de uma função que depende de estado externo produz respostas obsoletas. Funções parciais e o tipo opcional</h2> Divisão não é função total em $\mathbb{R}$: não está definida em zero. Linguagens tratam isso de três formas — exceção, valor sentinela ou tipo opcional (Option</code>, Maybe</code>, Result</code>). O tipo opcional é a solução que restaura a totalidade: em vez de $f: A \to B$ parcial, define-se $f: A \to B \cup {\text{nada}}$, que é total. Por isso o compilador consegue exigir que o caso ausente seja tratado — a informação passou a estar no tipo. Cardinalidade e contagem</h2> Para conjuntos finitos, o número de funções $A \to B$ é $|B|^{|A|}$ — daí a notação $B^A$. Cada elemento do domínio escolhe independentemente sua imagem. O número de funções injetoras de um conjunto de tamanho $k$ num de tamanho $n$ é $n(n-1)\cdots(n-k+1)$, que é zero quando $k > n$ — reencontrando a casa dos pombos. Erros comuns</h2> Confundir contradomínio com imagem. Sobrejetividade é justamente a afirmação de que os dois coincidem.</li> Chamar de função algo não determinístico. Isso invalida memoização e otimizações do compilador.</li> Supor que uma função injetora tem inversa sem verificar a sobrejetividade.</li> Esperar que hashing seja injetor. Comparar apenas hashes para decidir igualdade é um defeito, não uma otimização.</li> </ul> Kenneth H. Rosen (2019). Discrete Mathematics and Its Applications. McGraw-Hill. ISBN 9781259676512</a>. Paul R. Halmos (1974). Naive Set Theory. Springer. DOI: 10.1007/978-1-4757-1645-0</a>. Referências</h2> Kenneth H. Rosen (2019). Discrete Mathematics and Its Applications. McGraw-Hill.</li> Paul R. Halmos (1974). Naive Set Theory. Springer.</li> </ol> Grafos: Fundamentos 2026-07-26T00:00:00+00:00 Grafos: Fundamentos</h1> Grafo é a estrutura matemática mais versátil da computação. Redes sociais, dependências de pacotes, mapas rodoviários, grafos de chamada, autômatos, circuitos, fluxo de controle — todos são grafos. Saber traduzir um problema para grafo é frequentemente o passo que o resolve. Definições</h2> Um grafo é um par $G = (V, E)$ com $V$ um conjunto de vértices e $E$ um conjunto de arestas. Numa aresta ${u,v}$ dizemos que $u$ e $v$ são adjacentes. Grafo não dirigido: arestas são pares não ordenados.</li> Grafo dirigido (dígrafo): arestas são pares ordenados $(u,v)$.</li> Grafo ponderado: cada aresta tem um peso $w(u,v)$.</li> Multigrafo: permite arestas paralelas e laços.</li> </ul> O grau $\deg(v)$ é o número de arestas incidentes a $v$. Em dígrafos separa-se grau de entrada e de saída. Lema do aperto de mãos</h2> $$\sum_{v \in V} \deg(v) = 2|E|$$ Cada aresta contribui $1$ para o grau de cada extremidade. Consequência imediata: o número de vértices de grau ímpar é par. É um argumento de contagem simples que já resolve vários problemas — inclusive a caracterização dos grafos eulerianos. Representações</h2> Representação</th> Espaço</th> Testar aresta</th> Iterar vizinhos</th></tr></thead> Matriz de adjacência</td> $O(V^2)$</td> $O(1)$</td> $O(V)$</td></tr> Lista de adjacência</td> $O(V+E)$</td> $O(\deg v)$</td> $O(\deg v)$</td></tr> </tbody></table> A escolha depende da densidade. Um grafo é denso quando $|E| \approx |V|^2$ e esparso quando $|E| \approx |V|$. Grafos do mundo real quase sempre são esparsos: uma rede social com um bilhão de pessoas não tem $10^{18}$ arestas. Por isso a lista de adjacência é o padrão. # lista de adjacência grafo = { 'a': ['b', 'c'], 'b': ['a', 'd'], 'c': ['a', 'd'], 'd': ['b', 'c'], }</code></pre> Usar matriz de adjacência num grafo esparso grande é o erro de modelagem mais caro que existe nesta área: um grafo com $10^6$ vértices exigiria $10^{12}$ células. Caminhos, ciclos e conexidade</h2> Caminho: sequência de vértices ligados por arestas, sem repetição de vértices.</li> Ciclo: caminho que retorna ao início.</li> Grafo conexo: existe caminho entre quaisquer dois vértices.</li> Componente conexo: subgrafo conexo maximal.</li> </ul> Em dígrafos distingue-se fortemente conexo (caminho dirigido nos dois sentidos) de fracamente conexo (conexo ao ignorar as direções). Um grafo conexo com $|V|$ vértices tem pelo menos $|V|-1$ arestas; com exatamente $|V|-1$ e sem ciclo, é uma árvore. Travessias</h2> As duas travessias fundamentais diferem apenas na estrutura auxiliar — fila ou pilha — e essa diferença muda tudo. Busca em largura (BFS). Usa fila. Visita por camadas de distância crescente, o que dá o caminho mínimo em número de arestas. from collections import deque def bfs(grafo, inicio): visitados = {inicio} dist = {inicio: 0} fila = deque([inicio]) while fila: v = fila.popleft() for u in grafo[v]: if u not in visitados: visitados.add(u) dist[u] = dist[v] + 1 fila.append(u) return dist</code></pre> Busca em profundidade (DFS). Usa pilha (ou recursão). Vai fundo antes de voltar, e é a base de ordenação topológica, detecção de ciclos e componentes fortemente conexos. def dfs(grafo, v, visitados=None): if visitados is None: visitados = set() visitados.add(v) for u in grafo[v]: if u not in visitados: dfs(grafo, u, visitados) return visitados</code></pre> Ambas rodam em $\Theta(V + E)$ com lista de adjacência. Escolha BFS quando a distância importa e DFS quando a estrutura importa. Classes especiais</h2> Classe</th> Caracterização</th></tr></thead> Completo $K_n$</td> Toda aresta possível; $\binom{n}{2}$ arestas</td></tr> Bipartido</td> $V$ se divide em dois conjuntos sem arestas internas</td></tr> Árvore</td> Conexo e acíclico; $</td></tr> Planar</td> Pode ser desenhado sem cruzamento de arestas</td></tr> Regular</td> Todos os vértices com o mesmo grau</td></tr> </tbody></table> Grafos bipartidos têm uma caracterização útil: um grafo é bipartido se e somente se não tem ciclo de comprimento ímpar. O teste é uma BFS que colore em duas cores alternadas e falha ao encontrar uma aresta entre vértices da mesma cor. Para grafos planares conexos vale a fórmula de Euler: $$V - E + F = 2$$ com $F$ o número de faces. Dela decorre que um grafo planar simples tem $E \le 3V - 6$, o que prova que $K_5$ e $K_{3,3}$ não são planares. Exemplo trabalhado</h2> Quantas arestas tem $K_{10}$? Cada par de vértices define uma aresta: $$\binom{10}{2} = \frac{10 \cdot 9}{2} = 45$$ Cada vértice tem grau $9$, e o lema do aperto de mãos confere: $10 \cdot 9 = 90 = 2 \cdot 45$. Aplicações em computação</h2> Redes. Roteamento é caminho mínimo; detecção de partição é conexidade. Compiladores. O grafo de fluxo de controle guia otimizações; o grafo de dependências entre variáveis guia alocação de registradores. Sistemas de build. Dependências formam um DAG, e a ordem de compilação é uma ordenação topológica. Um ciclo é um erro de configuração. Web. O PageRank é o autovetor dominante da matriz de adjacência normalizada — um problema de grafo resolvido por álgebra linear. Verificação de modelos. Estados de um sistema formam um grafo; verificar uma propriedade é explorar alcançabilidade. Erros comuns</h2> Usar matriz de adjacência em grafo esparso grande.</li> Confundir BFS com DFS ao buscar caminho mínimo: só a BFS garante o mínimo em grafos não ponderados.</li> DFS recursiva em grafo grande estourando a pilha — em Python, o limite padrão é cerca de mil níveis.</li> Esquecer de marcar visitados e entrar em laço infinito em grafos com ciclo.</li> Tratar dígrafo como não dirigido e concluir conexidade que não existe.</li> </ul> Leituras recomendadas</h2> Cormen et al., parte VI — travessias, caminhos mínimos, fluxo máximo, com pseudocódigo e provas.</li> Diestel, Graph Theory — a referência teórica moderna; disponível gratuitamente no site do autor.</li> West, Introduction to Graph Theory — bom equilíbrio entre teoria e exercícios.</li> Kleinberg e Tardos, capítulo 3 — grafos do ponto de vista de projeto de algoritmos.</li> </ul> Thomas H. Cormen and Charles E. Leiserson and Ronald L. Rivest and Clifford Stein (2009). Introduction to Algorithms. MIT Press. ISBN 9780262533058</a>. Reinhard Diestel (2017). Graph Theory. Springer. DOI: 10.1007/978-3-662-53622-3</a>. Douglas B. West (2001). Introduction to Graph Theory. Prentice Hall. Página oficial</a>. Referências</h2> Thomas H. Cormen; Charles E. Leiserson; Ronald L. Rivest; Clifford Stein (2009). Introduction to Algorithms. MIT Press.</li> Reinhard Diestel (2017). Graph Theory. Springer.</li> Douglas B. West (2001). Introduction to Graph Theory. Prentice Hall.</li> </ol> Indução Matemática 2026-07-26T00:00:00+00:00 Indução Matemática</h1> Indução é a técnica que permite provar infinitas afirmações com um argumento finito. Para quem programa, ela é a contraparte exata da recursão: provar por indução é escrever a versão em papel do mesmo raciocínio que justifica uma função recursiva. O princípio</h2> Para provar que $P(n)$ vale para todo $n \ge n_0$: Base: mostre que $P(n_0)$ é verdadeiro.</li> Passo indutivo: mostre que, para todo $k \ge n_0$, se $P(k)$ vale então $P(k+1)$ vale.</li> </ol> A metáfora do dominó é boa: a base derruba a primeira peça, o passo garante que cada peça derruba a seguinte, e a conclusão é que todas caem. A hipótese $P(k)$ usada no passo é a hipótese de indução. Ela não é o que se quer provar — é o que se pode supor para provar o caso seguinte. Exemplo trabalhado</h2> Provar que $\displaystyle\sum_{i=1}^{n} i = \frac{n(n+1)}{2}$ para todo $n \ge 1$. Base. Para $n = 1$: o lado esquerdo é $1$ e o direito é $\frac{1 \cdot 2}{2} = 1$. Vale. Passo. Suponha $\sum_{i=1}^{k} i = \frac{k(k+1)}{2}$. Então: $$\sum_{i=1}^{k+1} i = \left(\sum_{i=1}^{k} i\right) + (k+1) = \frac{k(k+1)}{2} + (k+1)$$ $$= (k+1)\left(\frac{k}{2} + 1\right) = \frac{(k+1)(k+2)}{2}$$ que é exatamente a fórmula com $n = k+1$. Pelo princípio da indução, vale para todo $n \ge 1$. $\blacksquare$ Repare na mecânica: destacar o último termo, aplicar a hipótese ao resto e manipular até chegar à forma desejada. Esse é o roteiro da maioria das provas por indução sobre somas. Indução forte</h2> Às vezes $P(k)$ sozinho não basta e é preciso supor $P(n_0), P(n_0+1), \dots, P(k)$ — todos os casos anteriores. Essa variante é a indução forte, e é logicamente equivalente à simples. Ela é a forma natural quando o passo recursivo não reduz o problema em uma unidade. Exemplo clássico: todo inteiro $n \ge 2$ tem fator primo. Se $n$ é primo, pronto. Se não, $n = ab$ com $2 \le a, b < n$, e a hipótese forte se aplica a $a$ — mas $a$ pode ser bem menor que $n-1$, então a indução simples não serviria. O paralelo com algoritmos é direto: indução simples corresponde a recursão que decrementa em um; indução forte corresponde a dividir e conquistar, em que a chamada recursiva recebe um problema de tamanho arbitrariamente menor. Indução estrutural</h2> Generaliza a indução dos naturais para qualquer estrutura definida recursivamente — listas, árvores, fórmulas, expressões. Para provar que uma propriedade vale para toda árvore binária: Base: vale para a árvore vazia.</li> Passo: se vale para as subárvores esquerda e direita, vale para o nó que as combina.</li> </ol> Exemplo: provar que uma árvore binária com $n$ nós internos tem $n+1$ folhas. Base: árvore com $0$ nós internos é uma folha; $0 + 1 = 1$. Vale.</li> Passo: um nó interno com subárvores de $n_1$ e $n_2$ nós internos tem $n_1 + n_2 + 1$ nós internos e, pela hipótese, $(n_1+1) + (n_2+1) = n_1 + n_2 + 2$ folhas — que é o número de nós internos mais um. Vale.</li> </ul> Indução estrutural é a ferramenta padrão para provar propriedades de linguagens de programação: preservação de tipos, correção de um avaliador, terminação de uma normalização. Correção de algoritmos recursivos</h2> A correspondência é exata: Prova por indução</th> Algoritmo recursivo</th></tr></thead> Caso base</td> Caso base da recursão</td></tr> Hipótese de indução</td> Confiar que a chamada recursiva funciona</td></tr> Passo indutivo</td> Combinar os resultados corretamente</td></tr> Boa fundamentação</td> Garantia de terminação</td></tr> </tbody></table> def soma(lista): if not lista: # caso base return 0 return lista[0] + soma(lista[1:]) # passo</code></pre> Prova: para lista vazia devolve $0$, correto. Para lista de tamanho $k+1$, suponha que soma</code> está correta em listas de tamanho $k$; então devolve o primeiro elemento mais a soma do resto, que é a soma total. Este é o motivo pelo qual escrever uma função recursiva parece um ato de fé: você supõe que a chamada recursiva funciona, exatamente como a hipótese de indução. A fé é justificada desde que os argumentos decresçam segundo uma ordem bem fundada. Invariantes de laço: indução disfarçada</h2> Um laço se prova pelo mesmo mecanismo. O invariante é a propriedade $P$ que: vale antes da primeira iteração (base),</li> é preservada por cada iteração (passo),</li> combinada com a negação da condição de parada, dá a pós-condição.</li> </ol> def maximo(v): m = v[0] for i in range(1, len(v)): # invariante: m == max(v[0..i-1]) if v[i] > m: m = v[i] return m</code></pre> O invariante é o que transforma "parece certo" em "está certo". Erros comuns</h2> Esquecer o caso base. Sem ele nada se prova. O argumento "$n = n+1$ se $n-1 = n$" tem passo indutivo válido e nenhuma base.</li> Provar a base errada. Se o enunciado é para $n \ge 2$, a base é $n = 2$.</li> Usar a tese como hipótese. Supor $P(k+1)$ para provar $P(k+1)$ é circular.</li> Aplicar indução simples onde é preciso a forte, especialmente em algoritmos de dividir e conquistar.</li> Ignorar a boa fundamentação. Uma recursão cujos argumentos não decrescem numa ordem bem fundada pode não terminar, e a "prova" por indução não se aplica.</li> </ul> Leituras recomendadas</h2> Rosen, capítulo sobre indução e recursão — a apresentação mais didática e com mais exercícios resolvidos.</li> Graham, Knuth e Patashnik, Concrete Mathematics, capítulo 1 — indução aplicada a problemas de contagem, com o problema da Torre de Hanói como fio condutor.</li> Cormen et al., capítulo 2 — invariantes de laço aplicados à prova de correção do insertion sort.</li> </ul> Kenneth H. Rosen (2019). Discrete Mathematics and Its Applications. McGraw-Hill. ISBN 9781259676512</a>. Ronald L. Graham and Donald E. Knuth and Oren Patashnik (1994). Concrete Mathematics: A Foundation for Computer Science. Addison-Wesley. ISBN 9780134389967</a>. Thomas H. Cormen and Charles E. Leiserson and Ronald L. Rivest and Clifford Stein (2009). Introduction to Algorithms. MIT Press. ISBN 9780262533058</a>. Referências</h2> Kenneth H. Rosen (2019). Discrete Mathematics and Its Applications. McGraw-Hill.</li> Ronald L. Graham; Donald E. Knuth; Oren Patashnik (1994). Concrete Mathematics: A Foundation for Computer Science. Addison-Wesley.</li> Thomas H. Cormen; Charles E. Leiserson; Ronald L. Rivest; Clifford Stein (2009). Introduction to Algorithms. MIT Press.</li> </ol> Lógica de Predicados 2026-07-26T00:00:00+00:00 Lógica de Predicados</h1> A lógica proposicional não consegue expressar "todo elemento da lista é positivo" — ela trata cada proposição como um átomo sem estrutura interna. A lógica de predicados (ou de primeira ordem) acrescenta o que falta: variáveis, predicados e quantificadores. É a linguagem em que se escrevem especificações de programas, invariantes de laço e restrições de banco de dados. Predicados</h2> Um predicado é uma afirmação com variáveis livres, que só vira proposição quando as variáveis recebem valores. $P(x)$: "$x$ é primo" não tem valor de verdade; $P(7)$ tem. Predicados podem ter várias variáveis: $D(x, y)$ para "$x$ divide $y$". Quantificadores</h2> Quantificador</th> Símbolo</th> Leitura</th> Análogo em código</th></tr></thead> Universal</td> $\forall x, P(x)$</td> para todo $x$, $P(x)$</td> all(P(x) for x in D)</code></td></tr> Existencial</td> $\exists x, P(x)$</td> existe $x$ tal que $P(x)$</td> any(P(x) for x in D)</code></td></tr> </tbody></table> O quantificador sempre percorre um domínio. "$\forall x, (x^2 \ge 0)$" é verdadeiro nos reais e falso nos complexos. Omitir o domínio é a fonte mais comum de ambiguidade numa especificação. Dois casos-limite valem memorizar: sobre o domínio vazio, todo enunciado universal é verdadeiro e todo existencial é falso. Isso explica all([]) == True</code> e any([]) == False</code>. Negação de quantificadores</h2> As regras são o análogo direto de De Morgan, e são as mais usadas na prática: $\neg \forall x\, P(x) \;\equiv\; \exists x\, \neg P(x)</div>\neg \exists x\, P(x) \;\equiv\; \forall x\, \neg P(x)</div> Em português: negar "todos são pares" dá "existe um ímpar" — e não "todos são ímpares". A negação de uma propriedade universal é a existência de um contraexemplo, o que é a base de toda refutação matemática e de todo teste que encontra um defeito. A ordem dos quantificadores importa</h2> Este é o ponto que mais gera confusão, e vale um exemplo concreto. Seja $A(x, y)$ o predicado "$y$ é maior que $x$" sobre os inteiros: $\forall x, \exists y, A(x, y)$ — "para todo $x$ existe algum $y$ maior". Verdadeiro: basta tomar $y = x + 1$, e o $y$ pode depender de $x$.</li> $\exists y, \forall x, A(x, y)$ — "existe um $y$ maior que todos os $x$". Falso: exigiria um inteiro maior que qualquer outro.</li> </ul> Trocar a ordem mudou o valor de verdade. A regra prática: no primeiro caso a escolha de $y$ pode depender de $x$; no segundo, o mesmo $y$ tem de servir para todos. Essa distinção aparece direto em engenharia. "Toda requisição tem um servidor que a atende" é bem diferente de "existe um servidor que atende todas as requisições" — a primeira descreve um balanceador, a segunda um ponto único de falha. Escopo e variáveis livres</h2> Uma variável é ligada quando está sob o alcance de um quantificador, e livre caso contrário. Em $$\forall x, (P(x) \wedge Q(y))$$ $x$ é ligada e $y$ é livre. Uma fórmula sem variáveis livres é uma sentença e tem valor de verdade definido; com variáveis livres, ela é um predicado. A analogia com programação é exata: quantificador está para variável ligada assim como declaração de parâmetro está para variável local. Renomear a variável ligada não muda o significado, como renomear um parâmetro não muda a função. Exemplo trabalhado: especificando uma busca</h2> Especificar indice = busca(lista, alvo)</code>: $$\text{Se } \exists i, (0 \le i < n \wedge L[i] = alvo), \text{ então } L[\mathit{indice}] = alvo$$ $$\text{Se } \neg\exists i, (0 \le i < n \wedge L[i] = alvo), \text{ então } \mathit{indice} = -1$$ Aplicando a negação do existencial, a segunda condição vira $\forall i, (0 \le i < n \to L[i] \ne alvo)$ — que é exatamente o invariante que o laço da busca linear mantém a cada iteração. Aplicações em computação</h2> Invariantes de laço. A prova de correção de um laço consiste em mostrar que um predicado vale antes da primeira iteração, é preservado por cada iteração e, junto com a negação da condição de parada, implica a pós-condição. Contratos. Pré e pós-condições em ferramentas de verificação (Dafny, JML, Frama-C) são fórmulas de primeira ordem sobre o estado do programa. SQL. EXISTS</code> e NOT EXISTS</code> são quantificadores literais; WHERE NOT EXISTS (...)</code> é a tradução direta de $\neg\exists$. A divisão relacional — "clientes que compraram todos os produtos" — é um $\forall$ implementado como dupla negação. Prolog e programação lógica. Um programa é um conjunto de cláusulas de primeira ordem, e a execução é busca por prova. Resolvedores SMT. Ferramentas como Z3 decidem satisfatibilidade de fórmulas de primeira ordem sobre teorias (inteiros, vetores de bits, arranjos) e são o motor de muitos verificadores modernos[ref]</a> . Erros comuns</h2> Trocar a ordem dos quantificadores e supor que o significado se mantém.</li> Esquecer o domínio. "$\forall x, (x > 0 \to \sqrt{x} \text{ está definido})$" depende de estarmos nos reais.</li> Negar só o predicado. A negação de $\forall x, P(x)$ não é $\forall x, \neg P(x)$.</li> Usar $\wedge$ com $\forall$ em vez de $\to$. "Todo primo maior que 2 é ímpar" é $\forall x,(P(x) \wedge x>2 \to I(x))$; escrever $\forall x,(P(x) \wedge x>2 \wedge I(x))$ afirma que todo objeto do domínio é um primo ímpar maior que 2.</li> Supor que primeira ordem decide tudo. Validade em lógica de primeira ordem é indecidível — resolvedores são incompletos ou podem não terminar.</li> </ul> Herbert B. Enderton (2001). A Mathematical Introduction to Logic. Academic Press. DOI: 10.1016/c2009-0-22107-6</a>. Michael Huth and Mark Ryan (2004). Logic in Computer Science: Modelling and Reasoning about Systems. Cambridge University Press. DOI: 10.1017/cbo9780511810275</a>. Referências</h2> Herbert B. Enderton (2001). A Mathematical Introduction to Logic. Academic Press.</li> Michael Huth; Mark Ryan (2004). Logic in Computer Science: Modelling and Reasoning about Systems. Cambridge University Press.</li> </ol> Lógica Proposicional 2026-07-26T00:00:00+00:00 Lógica Proposicional</h1> A lógica proposicional é o sistema formal mais simples capaz de expressar raciocínio. Para quem programa, ela não é um tópico abstrato: é a semântica exata do if</code>. Toda condição de desvio, toda cláusula WHERE</code> de SQL, todo circuito combinacional é uma fórmula proposicional. Proposições e conectivos</h2> Uma proposição é uma sentença à qual se pode atribuir um único valor de verdade: verdadeiro ($V$) ou falso ($F$). "$2 + 2 = 4$" é proposição; "feche a porta" não é. Proposições se combinam por conectivos: Conectivo</th>Símbolo</th>Leitura</th>Em código</th></tr></thead> Negação</td>$\neg p$</td>não $p$</td>!p</code></td></tr> Conjunção</td>$p \wedge q$</td>$p$ e $q$</td>p && q</code></td></tr> Disjunção</td>$p \vee q$</td>$p$ ou $q$</td>p || q</code></td></tr> Condicional</td>$p \to q$</td>se $p$, então $q$</td>!p || q</code></td></tr> Bicondicional</td>$p \leftrightarrow q$</td>$p$ se e somente se $q$</td>p == q</code></td></tr> </tbody></table> Tabelas-verdade</h2> A semântica de cada conectivo é dada exaustivamente: $p$</th>$q$</th>$\neg p$</th>$p \wedge q$</th>$p \vee q$</th>$p \to q$</th>$p \leftrightarrow q$</th></tr></thead> V</td>V</td>F</td>V</td>V</td>V</td>V</td></tr> V</td>F</td>F</td>F</td>V</td>F</td></tr> F</td>V</td>V</td>F</td>V</td>F</td></tr> F</td>F</td>V</td>F</td>F</td>V</td></tr> </tbody></table>$

Matemática para Computação

Bibliografia Comentada

Bibliografia Comentada</h1> Lista de referências por área, com uma indicação honesta de nível e de para que cada livro serve. Vários estão disponíveis legalmente de graça — marcados com (livre)</strong>.</p>

Guia de Notação

Guia de Notação</h1> Referência rápida dos símbolos usados neste guia. Notação é convenção, e convenções variam entre áreas — quando houver ambiguidade, ela é apontada.</p>

Roteiros de Estudo

Roteiros de Estudo</h1> O guia não precisa ser lido em ordem. Abaixo, percursos por objetivo — cada um levando de umas poucas horas a algumas semanas, conforme a profundidade desejada.</p>

Preparação para entrevistas técnicas</h2> Foco no que efetivamente é cobrado.</p>

Aprendizado de máquina</h2> O percurso mais longo, e o que exige mais álgebra linear.</p>

Autovalores e Autovetores

Autovalores e Autovetores</h1> Autovalores respondem a uma pergunta específica: existem direções que a transformação apenas estica ou encolhe</strong>, sem girar? Essas direções revelam a estrutura essencial da matriz e são a base do PCA, do PageRank e da análise de estabilidade.</p>

Referências</h2> Gilbert Strang (2016). Introduction to Linear Algebra</em>. Wellesley-Cambridge Press.</li> Sheldon Axler (2015). Linear Algebra Done Right</em>. Springer.</li> Lloyd N. Trefethen; David Bau III (1997). Numerical Linear Algebra</em>. SIAM.</li> </ol>

Decomposições LU e Cholesky

Determinante

Determinante</h1> O determinante é um número associado a uma matriz quadrada que responde a uma pergunta geométrica: quanto a transformação multiplica volumes, e ela inverte a orientação?</strong></p>

Espaços Vetoriais

Combinação linear e geração</h2> Uma combinação linear</strong> de $v_1, \dots, v_k$ é</p> $$c_1 v_1 + c_2 v_2 + \cdots + c_k v_k$$</p> O espaço gerado</strong> $\operatorname{span}{v_1,\dots,v_k}$ é o conjunto de todas essas combinações. Ele é sempre um subespaço.</p>

Matrizes e Operações

Matrizes e Operações</h1> 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.</p>

Ortogonalidade e Fatoração QR

Produto Interno e Normas

Produto Interno e Normas</h1> Produto interno e norma acrescentam geometria</strong> ao espaço vetorial: comprimento, ângulo, distância e ortogonalidade. Sem eles, um espaço vetorial não sabe o que é "perto".</p>

Exemplo trabalhado</h2> Para $u = (3,4)$ e $v = (1,0)$:</p> $$|u|_2 = 5, \quad |u|1 = 7, \quad |u|</em>\infty = 4$$</p> $$\langle u,v\rangle = 3, \quad \cos\theta = \frac{3}{5 \cdot 1} = 0{,}6$$</p> Cauchy-Schwarz confere: $|3| \le 5 \cdot 1$.</p>

Sistemas Lineares

Sistemas Lineares</h1> Resolver $Ax = b$ é o problema computacional mais executado do mundo. Ele aparece dentro de simulação física, ajuste de modelos, otimização, gráficos e praticamente todo método numérico.</p>

Decomposição em Valores Singulares

Bibliografia Comentada</h1>
Lista de referências por área, com uma indicação honesta de nível e de para que cada livro serve. Vários estão disponíveis legalmente de graça — marcados com (livre)</strong>.</p>

Guia de Notação</h1>
Referência rápida dos símbolos usados neste guia. Notação é convenção, e convenções variam entre áreas — quando houver ambiguidade, ela é apontada.</p>

Roteiros de Estudo</h1>
O guia não precisa ser lido em ordem. Abaixo, percursos por objetivo — cada um levando de umas poucas horas a algumas semanas, conforme a profundidade desejada.</p>

Autovalores e Autovetores</h1>
Autovalores respondem a uma pergunta específica: existem direções que a transformação apenas estica ou encolhe</strong>, sem girar? Essas direções revelam a estrutura essencial da matriz e são a base do PCA, do PageRank e da análise de estabilidade.</p>

Referências</h2>

Gilbert Strang (2016). Introduction to Linear Algebra</em>. Wellesley-Cambridge Press.</li>
Sheldon Axler (2015). Linear Algebra Done Right</em>. Springer.</li>
Lloyd N. Trefethen; David Bau III (1997). Numerical Linear Algebra</em>. SIAM.</li> </ol>

Determinante</h1>
O determinante é um número associado a uma matriz quadrada que responde a uma pergunta geométrica: quanto a transformação multiplica volumes, e ela inverte a orientação?</strong></p>

Combinação linear e geração</h2>
Uma combinação linear</strong> de $v_1, \dots, v_k$ é</p>
$$c_1 v_1 + c_2 v_2 + \cdots + c_k v_k$$</p>
O espaço gerado</strong> $\operatorname{span}{v_1,\dots,v_k}$ é o conjunto de todas essas combinações. Ele é sempre um subespaço.</p>

Matrizes e Operações</h1>
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.</p>

Produto Interno e Normas</h1>
Produto interno e norma acrescentam geometria</strong> ao espaço vetorial: comprimento, ângulo, distância e ortogonalidade. Sem eles, um espaço vetorial não sabe o que é "perto".</p>

Exemplo trabalhado</h2>
Para $u = (3,4)$ e $v = (1,0)$:</p>
$$|u|_2 = 5, \quad |u|1 = 7, \quad |u|</em>\infty = 4$$</p>
$$\langle u,v\rangle = 3, \quad \cos\theta = \frac{3}{5 \cdot 1} = 0{,}6$$</p>
Cauchy-Schwarz confere: $|3| \le 5 \cdot 1$.</p>

Sistemas Lineares</h1>
Resolver $Ax = b$ é o problema computacional mais executado do mundo. Ele aparece dentro de simulação física, ajuste de modelos, otimização, gráficos e praticamente todo método numérico.</p>