---
title: "Matrislerle Eliminasyon"
subtitle: "Gauss eliminasyonu, pivot, E matrisleri ve EA = U"
---
::: {.callout-note title="Bölüm bilgisi"}
- **Strang'in videosu:** [YouTube — Lecture 2: Elimination with Matrices](https://www.youtube.com/watch?v=QVKj3LADCnA) (≈47 dk)
- **OCW sayfası:** [MIT 18.06SC — Lecture 2](https://ocw.mit.edu/courses/18-06sc-linear-algebra-fall-2011/resources/elimination-with-matrices/)
- **Okuma süresi:** ≈40 dk
:::
## Bu Derste Ne Var? {#sec-bu-derste}
Ders 1'de "lineer sistemin geometrisi ne?" sorusunu işledik. Şimdi pratik soru: **bu sistemi nasıl çözeriz?** Strang'in açış cümlesi sert — *"every software package solves equations"* yöntemiyle, yani **eliminasyon** ile. numpy, MATLAB, LAPACK, PyTorch — hangi sayısal kütüphaneye baksan, $A\mathbf{x} = \mathbf{b}$ tipi sistemleri çözerken arka planda yapılan budur. Determinant değil; eliminasyon.
**Üç ana parça:**
1. **İleri eliminasyon** — $A$'yı sistematik satır işlemleriyle üst üçgensel $U$ matrisine dönüştür.
2. **Geri yerine koyma** — Üst üçgensel $U\mathbf{x} = \mathbf{c}$'den çözümü alttan yukarı oku.
3. **Matris dili** — Her satır işlemini bir eliminasyon matrisi $E_{ij}$ olarak yaz; tüm zincir $EA = U$ olur.
Üçüncü parça en kritik olanı; Strang dersin yarısını buna ayırıyor. Sebep: **LU ayrışımı** (Ders 4), **ters matris** (Ders 3) ve modern numerik LA hep bu $E$ matrisleri üzerine kurulu.
```{mermaid}
%%| label: fig-concept-map
%%| fig-cap: "Gauss eliminasyonu üç katmanlı: hesaplama → matris dili → ML köprüleri."
flowchart LR
A["A·x = b<br/>(genel sistem)"] --> F["İleri Eliminasyon<br/>A → U (üst üçgensel)"]
F --> B["Geri Yerine Koyma<br/>U·x = c → x"]
F --> E["📐 Matris dili<br/>E_ij eliminasyon matrisleri"]
E --> EA["E·A = U<br/>(tüm zincir tek matris)"]
EA --> LU["💡 A = L·U<br/>(Ders 4)"]
LU --> ML["⚡ np.linalg.solve<br/>torch.linalg.lu_factor<br/>LAPACK getrf"]
style A fill:#fdf6f7,stroke:#8a1538,stroke-width:2px
style E fill:#fff3e0,stroke:#e67e22,stroke-width:3px
style ML fill:#fce4ec,stroke:#c2185b,stroke-width:3px
```
::: {.callout-tip title="Builder Notu — Eliminasyon Her Yerde"}
Gauss eliminasyonunu elle yazmazsın. Ama her yerde:
- **`np.linalg.solve(A, b)`** arka planda LAPACK `getrf` çağırır — partial pivoting'li Gauss eliminasyonu.
- **Linear regression normal equations**, **ridge regression**, **Newton's method**, **Kalman filter** — hepsi `solve` çağırır.
- **Matris çarpımının "satır mı, kolon mu" sezgisi** (bu derste netleşecek) attention mekanizmasından dense layer'a kadar her yerde lazım.
- **Çarpımın birleşmeliği (associative)** Flash Attention'ın temeli — aynı sonuç, farklı parantez, dramatik bellek tasarrufu.
:::
## Problem — Strang'in 3×3 Sistemi {#sec-problem}
Somut sistem:
$$
\begin{aligned}
x + 2y + z &= 2 \\
3x + 8y + z &= 12 \\
\phantom{0x +\,} 4y + z &= 2
\end{aligned}
$$
(Üçüncü denklemde $x$ katsayısı $0$.) Matris formunda:
$$
A = \begin{pmatrix} 1 & 2 & 1 \\ 3 & 8 & 1 \\ 0 & 4 & 1 \end{pmatrix}, \quad \mathbf{b} = \begin{pmatrix} 2 \\ 12 \\ 2 \end{pmatrix}
$$
**Strateji:** $A$'yı satır işlemleriyle **üst üçgensel** $U$'ya dönüştür. Üst üçgensel sistemler kolay çözülür — alttan yukarı, her satırda tek bilinmeyen kalır.
## İleri Eliminasyon — Adım Adım {#sec-ileri-eliminasyon}
Hedef: $A$'nın köşegen altındaki tüm girdileri sıfırlamak.
**Adım 1: (2,1) sıfırla.** İlk pivot = sol üst köşe **1**. İkinci satırdaki 3'ü silmek için **3 × satır 1'i, satır 2'den çıkar**.
- Yeni satır 2 = $(3, 8, 1) - 3 \cdot (1, 2, 1) = (0, 2, -2)$
- Çarpan $\ell_{21} = 3$.
$$
\begin{pmatrix} \boxed{1} & 2 & 1 \\ 3 & 8 & 1 \\ 0 & 4 & 1 \end{pmatrix}
\;\longrightarrow\;
\begin{pmatrix} 1 & 2 & 1 \\ 0 & 2 & -2 \\ 0 & 4 & 1 \end{pmatrix}
$$
**Adım 2: (3,1) sıfırla.** Üçüncü satırın 1. elemanı zaten 0. $\ell_{31} = 0$, geç.
**Adım 3: (3,2) sıfırla.** İkinci pivot = satır 2'deki yeni **2**. Üçüncü satırdaki 4'ü silmek için **2 × satır 2'yi, satır 3'ten çıkar**.
- Yeni satır 3 = $(0, 4, 1) - 2 \cdot (0, 2, -2) = (0, 0, 5)$
- Çarpan $\ell_{32} = 2$.
$$
U = \begin{pmatrix} \boxed{1} & 2 & 1 \\ 0 & \boxed{2} & -2 \\ 0 & 0 & \boxed{5} \end{pmatrix}
$$
**Pivotlar: $1, 2, 5$.**
```{python}
#| label: fig-eliminasyon-adimlar
#| fig-cap: "Eliminasyonun üç anlık görüntüsü: orijinal $A$ → $E_{21}$ sonrası → $E_{32}$ sonrası $U$. Renkli hücreler değişeni gösterir; sıfır pozisyonları beyaza döner."
#| fig-width: 13
#| fig-height: 4
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import LinearSegmentedColormap
A = np.array([[1, 2, 1], [3, 8, 1], [0, 4, 1]], dtype=float)
A1 = np.array([[1, 2, 1], [0, 2, -2], [0, 4, 1]], dtype=float)
U = np.array([[1, 2, 1], [0, 2, -2], [0, 0, 5]], dtype=float)
mats = [A, A1, U]
titles = [r'$A$ (orijinal)', r'$E_{21} A$ (3·r1 → r2)', r'$U = E_{32} E_{21} A$ (2·r2 → r3)']
changed = [
np.zeros_like(A, dtype=bool),
np.array([[0,0,0],[1,1,1],[0,0,0]], dtype=bool),
np.array([[0,0,0],[0,0,0],[1,1,1]], dtype=bool),
]
fig, axes = plt.subplots(1, 3, figsize=(13, 4))
for ax, M, t, ch in zip(axes, mats, titles, changed):
for i in range(3):
for j in range(3):
val = M[i, j]
color = '#fdf6f7' if val == 0 else ('#fed7aa' if ch[i, j] else '#dbeafe')
ax.add_patch(plt.Rectangle((j, 2-i), 1, 1, facecolor=color, edgecolor='#475569', linewidth=1.5))
ax.text(j+0.5, 2-i+0.5, f'{val:g}', ha='center', va='center',
fontsize=18, fontweight='bold',
color='#1e293b' if val != 0 else '#cbd5e0')
# pivotlari isaretle
pivot_pos = [(0,0), (1,1), (2,2)] if M is U else ([(0,0)] if M is A else [(0,0), (1,1)])
for (pi, pj) in pivot_pos:
if M[pi, pj] != 0:
ax.add_patch(plt.Rectangle((pj, 2-pi), 1, 1, facecolor='none', edgecolor='#8a1538', linewidth=3))
ax.set_xlim(0, 3); ax.set_ylim(0, 3); ax.set_aspect('equal')
ax.set_xticks([]); ax.set_yticks([])
ax.set_title(t, fontsize=11)
for s in ax.spines.values(): s.set_visible(False)
plt.tight_layout()
plt.show()
```
> *"This matrix is great. It gave me three pivots, I didn't have to do anything special, I just followed the rules."* — Strang, 10:00
**Pivot Notu:**
- Üç pivot, hiçbiri sıfır değil → $A$ invertible (Ders 3 detay).
- Determinant = pivotların çarpımı = $1 \times 2 \times 5 = 10$ (Strang: "I never want to know" — determinanta nadiren bakacağız, ama burada bedava çıktı).
- Pivot işaretleri matrisin **pozitif tanımlılığı** hakkında ipucu (Ders 25).
## Başarısızlık Modları — Pivot Sıfır {#sec-basarisizlik}
**Geçici başarısızlık — Satır takasıyla kurtuluş:**
Pivot pozisyonunda 0 var. Aşağıdaki bir satırla yer değiştir, eliminasyona devam.
> *"I will never be heard to utter those words, '0 pivot'. But if there's a 0 in the pivot position, I would try to exchange for a lower equation."* — Strang, 11:25
**Strang'in örneği:** $A$'daki 8 yerine 6 olsaydı, ikinci pivot $6 - 3 \cdot 2 = 0$ olurdu. Satır 2 ile satır 3'ü takas et — kurtuluş.
**Tam başarısızlık — Kurtuluş yok:**
Pivot 0 ve aşağıdaki tüm girdiler de 0. O zaman matris **singular** — ya sonsuz çözüm ya hiç çözüm. Ders 1'deki $\mathbf{c}_3 = \mathbf{c}_1 + \mathbf{c}_2$ örneğindeki durum.
::: {.callout-tip title="Builder Notu — Numerik Stabilite ve Partial Pivoting"}
Pratikte (numpy, LAPACK) sadece "sıfır mı değil mi" diye bakılmaz. **Çok küçük pivot** da problemlidir — float aritmetikte küçük sayıyla bölme = patlayan hata.
Gerçek implementasyonlar **partial pivoting** yapar: her adımda kolondaki en büyük (mutlak değer) elemanı pivot olarak seçer, ona göre satır takası. `np.linalg.solve` arka planda bunu yapar; sen "küçük sayılar pivotta olmasın" diye düşünmek zorunda değilsin. Ama bilmek lazım: pivot seçimi sayısal sağlamlık için kritik.
ML'de bu sezgi şuralarda karşına çıkar:
- **Batch normalization** — küçük varyansa bölmenin patlamasını önlemek için $\sqrt{\sigma^2 + \epsilon}$.
- **Layer norm**, **RMSNorm** — aynı motivasyon.
- **Cholesky factorization** — pozitif tanımlı matrisler için "pivoting-free" alternatif.
:::
## Geri Yerine Koyma {#sec-back-sub}
Eliminasyon $A$'yı $U$'ya dönüştürdü. Sağ tarafa da aynı işlemleri uygulayalım. **Augmented matris** $[A \mid \mathbf{b}]$:
$$
[A \mid \mathbf{b}] = \begin{pmatrix} 1 & 2 & 1 & \big| & 2 \\ 3 & 8 & 1 & \big| & 12 \\ 0 & 4 & 1 & \big| & 2 \end{pmatrix}
$$
Aynı çarpanları $\mathbf{b}$'ye uygula:
- Yeni $b_2 = 12 - 3 \cdot 2 = 6$
- Yeni $b_3 = 2 - 2 \cdot 6 = -10$
$$
[U \mid \mathbf{c}] = \begin{pmatrix} 1 & 2 & 1 & \big| & 2 \\ 0 & 2 & -2 & \big| & 6 \\ 0 & 0 & 5 & \big| & -10 \end{pmatrix}
$$
**Alttan yukarı çöz:**
- $5z = -10 \Rightarrow z = -2$
- $2y - 2z = 6 \Rightarrow 2y + 4 = 6 \Rightarrow y = 1$
- $x + 2y + z = 2 \Rightarrow x + 2 - 2 = 2 \Rightarrow x = 2$
**Çözüm:** $(x, y, z) = (2, 1, -2)$.
Orijinalde doğrula:
- $2 + 2 - 2 = 2$ ✓
- $6 + 8 - 2 = 12$ ✓
- $4 - 2 = 2$ ✓
## Matris Dili — $E_{ij}$ ile Yazmak {#sec-matris-dili}
Strang dersin ikinci yarısında devasa bir adım: **yukarıdaki tüm satır işlemlerini matris çarpımı olarak yaz**.
> *"All the key ideas get expressed as matrix operations, not as words."* — Strang, 2:16
İki bakış lazım:
**Bakış 1 (Ders 1'den):** Matris × kolon vektör = matrisin **kolonlarının** lineer kombinasyonu.
**Bakış 2 (YENİ):** Satır vektör × matris = matrisin **satırlarının** lineer kombinasyonu.
$$
\begin{pmatrix} 1 & 2 & 7 \end{pmatrix} \begin{pmatrix} - & \mathbf{r}_1 & - \\ - & \mathbf{r}_2 & - \\ - & \mathbf{r}_3 & - \end{pmatrix} = 1 \mathbf{r}_1 + 2 \mathbf{r}_2 + 7 \mathbf{r}_3
$$
::: {.callout-important title="Anahtar Prensip"}
**Soldan çarpma → satır işlemleri.**
**Sağdan çarpma → kolon işlemleri.**
:::
Eliminasyon satır işlemleri olduğu için, eliminasyon matrisleri $A$'nın **soluna** çarpılır.
## Eliminasyon Matrisleri {#sec-E-matrisleri}
**$E_{21}$ — İlk adım:** "Satır 1 değişmesin, satır 3 değişmesin, satır 2 → satır 2 − 3·satır 1."
$$
E_{21} = \begin{pmatrix} 1 & 0 & 0 \\ -3 & 1 & 0 \\ 0 & 0 & 1 \end{pmatrix}
$$
Her satırı "satır vektör × matris" mantığıyla yorumla:
- Satır 1 $(1, 0, 0)$: $1 \mathbf{r}_1$ → değişmedi ✓
- Satır 2 $(-3, 1, 0)$: $-3\mathbf{r}_1 + \mathbf{r}_2$ → istediğimiz ✓
- Satır 3 $(0, 0, 1)$: $\mathbf{r}_3$ → değişmedi ✓
**Genel kural:** $E_{ij}$ identity matristen $(i, j)$ konumuna **çarpanın negatifi** yazılarak elde edilir.
**$E_{32}$ — İkinci adım:**
$$
E_{32} = \begin{pmatrix} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & -2 & 1 \end{pmatrix}
$$
**Tüm zincir:** $E_{32}(E_{21} A) = U$.
```{python}
#| label: code-E-zincir
#| code-fold: false
import numpy as np
A = np.array([[1, 2, 1], [3, 8, 1], [0, 4, 1]], dtype=float)
E21 = np.array([[1, 0, 0], [-3, 1, 0], [0, 0, 1]], dtype=float)
E32 = np.array([[1, 0, 0], [0, 1, 0], [0, -2, 1]], dtype=float)
U_kademeli = E32 @ (E21 @ A)
E = E32 @ E21
U_birden = E @ A
print("E (toplu eliminasyon):\n", E)
print("\nE @ A:\n", U_birden)
print("\nE32 @ (E21 @ A):\n", U_kademeli)
print("\nFark:", np.linalg.norm(U_kademeli - U_birden)) # 0 olmalı
```
## Birleşme Yasası — Parantezleri Kaydır {#sec-associative}
> *"You can move the parentheses... this is highly important. So many proofs of main facts come from just moving the parentheses."* — Strang, 35:36
$$
E_{32}(E_{21} A) = (E_{32} E_{21}) A
$$
İki taraf aynı. Bu yüzden tek bir $E = E_{32} E_{21}$ matrisi tanımlayıp tüm eliminasyonu bir hamlede uygulayabiliriz.
**DİKKAT — Değişme yasası yok:** $AB \neq BA$ genelde. Eliminasyonda sıra önemli — önce $E_{21}$ (sağda, ilk uygulanır), sonra $E_{32}$ (solda, sonra uygulanır). Sırayı karıştırırsan farklı matris çıkar.
::: {.callout-tip title="Builder Notu — Flash Attention ve Associative Law"}
Attention formülü:
$$
\text{Attention}(Q, K, V) = \text{softmax}\!\left(\tfrac{QK^T}{\sqrt{d}}\right) V
$$
Sequence uzunluğu $n$ büyüdükçe $QK^T$ matrisi $n \times n$ — bellek katlar ($n = 8192$ için $\sim 256$ MB tek bir attention map için).
**Flash Attention** ([Dao et al., 2022](https://arxiv.org/abs/2205.14135)) associative law ve softmax'ın çevrimiçi (online) güncellenebilirliğini kullanarak çarpım sırasını yeniden düzenler — ara matrisi hiç oluşturmadan sonucu hesaplar. Aynı matematik, farklı parantez, çok daha az HBM erişimi.
Bu derste öğrendiğin "parantezleri kaydır" sezgisi, transformer optimizasyonunun temel taşı.
:::
## Permütasyon Matrisleri {#sec-permutation}
Pivot sıfır geldiyse satır takası gerek. Bu da bir matris çarpımı:
$$
P = \begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix}, \quad P \begin{pmatrix} a & b \\ c & d \end{pmatrix} = \begin{pmatrix} c & d \\ a & b \end{pmatrix}
$$
(Soldan çarpma → satır işlemi → satırları takas.)
Sağdan çarptığında **kolonları** takas eder. Pratik implementasyonlarda her zaman $P, L, U$ üçlüsü saklanır:
$$
PA = LU
$$
Bu Ders 4'ün ana sonucu olacak — numerik LA'nın en yaygın ayrışımı.
## Ters Matrise İlk Bakış {#sec-tersmatris-onsoz}
Strang sonu sonraki dersin köprüsüyle bağlıyor. **$E_{21}$ ne yaptıysa, hangi matris geri alır?**
$$
E_{21} = \begin{pmatrix} 1 & 0 & 0 \\ -3 & 1 & 0 \\ 0 & 0 & 1 \end{pmatrix} \quad\to\quad E_{21}^{-1} = \begin{pmatrix} 1 & 0 & 0 \\ 3 & 1 & 0 \\ 0 & 0 & 1 \end{pmatrix}
$$
Sadece işaret değişti: $-3 \to +3$ (eliminasyonun tersi: "3 katı çıkardıysan, 3 katı ekle").
**Ana özellik:** $E_{21}^{-1} \cdot E_{21} = I$.
```{python}
#| label: fig-LU-yapisi
#| fig-cap: "$A = LU$ ayrışımı: $L$ alt üçgensel (eliminasyon çarpanları), $U$ üst üçgensel (pivot + üst tarafı). Köşegen $L$'de 1'ler, $U$'da pivotlar."
#| fig-width: 11
#| fig-height: 4
A = np.array([[1, 2, 1], [3, 8, 1], [0, 4, 1]], dtype=float)
L = np.array([[1, 0, 0], [3, 1, 0], [0, 2, 1]], dtype=float)
U = np.array([[1, 2, 1], [0, 2, -2], [0, 0, 5]], dtype=float)
def draw_matrix(ax, M, title, lower=False, upper=False):
n = M.shape[0]
for i in range(n):
for j in range(n):
val = M[i, j]
if val == 0:
color = '#f1f5f9'
elif lower and i > j:
color = '#fed7aa' # L: kosegen alti
elif lower and i == j:
color = '#fbbf24' # L: kosegen (hepsi 1)
elif upper and i == j:
color = '#fbbf24' # U: pivot
elif upper and i < j:
color = '#bfdbfe' # U: kosegen ustu
else:
color = '#e0e7ff'
ax.add_patch(plt.Rectangle((j, n-1-i), 1, 1, facecolor=color, edgecolor='#475569', linewidth=1.5))
ax.text(j+0.5, n-1-i+0.5, f'{val:g}', ha='center', va='center',
fontsize=18, fontweight='bold',
color='#1e293b' if val != 0 else '#cbd5e0')
ax.set_xlim(0, n); ax.set_ylim(0, n)
ax.set_aspect('equal'); ax.set_xticks([]); ax.set_yticks([])
ax.set_title(title, fontsize=12)
for s in ax.spines.values(): s.set_visible(False)
fig, axes = plt.subplots(1, 3, figsize=(11, 4))
draw_matrix(axes[0], A, r'$A$')
draw_matrix(axes[1], L, r'$L$ (alt üçgensel, köşegen = 1)', lower=True)
draw_matrix(axes[2], U, r'$U$ (üst üçgensel, pivotlar = 1, 2, 5)', upper=True)
fig.suptitle(r'$A = L U$ — Ders 4\'ün önizlemesi', fontsize=13, y=1.02)
plt.tight_layout()
plt.show()
# Sayisal dogrulama
print("L @ U =\n", L @ U)
print("\nA =\n", A)
print("\nFark:", np.linalg.norm(L @ U - A)) # 0 olmali
```
## Bu Dersin Özeti {#sec-ozet}
1. **Gauss eliminasyonu**: $A\mathbf{x} = \mathbf{b}$'yi sistematik çözmenin algoritması.
2. **İleri eliminasyon**: $A \to U$ (üst üçgensel).
3. **Pivot**: her kolonda referans eleman, sıfır olamaz.
4. **Başarısızlık modları**: pivot sıfır → satır takası (kurtuluş) ya da singular (kurtuluş yok).
5. **Geri yerine koyma**: $U\mathbf{x} = \mathbf{c}$'yi alttan yukarı çöz.
6. **Matris dili**: Her satır işlemi bir $E_{ij}$. Soldan çarpma = satır işlemi.
7. **Birleşme yasası**: $E_{32}(E_{21} A) = (E_{32} E_{21}) A = EA = U$.
8. **Permütasyon**: $P$ satır takası matrisi → $PA = LU$ (Ders 4).
9. **Ters matris**: her $E$ için $E^{-1}$ — Ders 3'ün konusu.
::: {.callout-important title="Tek bir cümle"}
Eliminasyon, $A$'yı bir dizi $E_{ij}$ matrisiyle soldan çarparak üst üçgensel $U$'ya dönüştürür: **$EA = U$**. Sonraki derslerde bu denklem $A = LU$ olarak ters yüz olacak ve numerik LA'nın omurgası çıkacak.
:::
## Kontrol Soruları {#sec-sorular}
::: {.callout-note collapse="true" title="Soru 1: A = ((2,1),(6,8)) için ileri eliminasyon — pivot, çarpan, U."}
İlk pivot: $2$. Çarpan: $\ell_{21} = 6/2 = 3$.
Yeni satır 2: $(6, 8) - 3 \cdot (2, 1) = (0, 5)$.
$$
U = \begin{pmatrix} 2 & 1 \\ 0 & 5 \end{pmatrix}
$$
Pivotlar: $2, 5$. Determinant $= 10$.
:::
::: {.callout-note collapse="true" title="Soru 2: Aynı örnek için E_{21} matrisini yaz ve E_{21} A = U olduğunu doğrula."}
$$
E_{21} = \begin{pmatrix} 1 & 0 \\ -3 & 1 \end{pmatrix}
$$
(2, 1) konumunda çarpanın negatifi $-3$. Çarpım:
$$
E_{21} A = \begin{pmatrix} 1 & 0 \\ -3 & 1 \end{pmatrix} \begin{pmatrix} 2 & 1 \\ 6 & 8 \end{pmatrix} = \begin{pmatrix} 2 & 1 \\ 0 & 5 \end{pmatrix} = U \checkmark
$$
:::
::: {.callout-note collapse="true" title="Soru 3: Aşağıdaki matriste eliminasyon problem çıkarır — satır takası yardım eder mi?"}
$$
A = \begin{pmatrix} 1 & 2 & 3 \\ 2 & 4 & 1 \\ 0 & 1 & 5 \end{pmatrix}
$$
İlk adım: $\ell_{21} = 2$, satır 2 → $(0, 0, -5)$.
$$
\to \begin{pmatrix} 1 & 2 & 3 \\ 0 & 0 & -5 \\ 0 & 1 & 5 \end{pmatrix}
$$
$(2, 2)$ pozisyonunda **0** var. Ama altında satır 3'te 1 var. Satır 2 ↔ satır 3 takas:
$$
\to \begin{pmatrix} 1 & 2 & 3 \\ 0 & 1 & 5 \\ 0 & 0 & -5 \end{pmatrix} = U
$$
Pivotlar $1, 1, -5$. Matris singular değil — pivot sırasını düzeltmek gerekti. Buna **partial pivoting** denir.
:::
::: {.callout-note collapse="true" title="Soru 4: (Builder) np.linalg.solve(A, b) ne yapar — neden np.linalg.inv(A) @ b yazmıyoruz?"}
İki ayrı sebep:
1. **Sayısal sağlamlık.** `solve` Gauss + partial pivoting kullanır. `inv` tüm tersi hesaplar — çok daha fazla işlem ve hata birikimi. Sadece $A\mathbf{x} = \mathbf{b}$'yi çözüyorsan, tüm tersi bilmeye gerek yok.
2. **Hız.** `solve` $\approx n^3/3$ flop. `inv` ardından `inv @ b` $\approx n^3$ flop. Yaklaşık 3× yavaş.
**Genel kural:** $A^{-1}\mathbf{b}$ yazmak istediğin her yerde `np.linalg.solve(A, b)` yaz. Newton's method, normal equations, Cholesky tabanlı işlemler, hepsinde geçerli. PyTorch: `torch.linalg.solve`.
:::
## Egzersizler {#sec-egzersizler}
**Egzersiz 1.** Aşağıdaki sistemde ileri eliminasyon + geri yerine koyma yap. $U$, çarpanlar, $\mathbf{x}$.
$$
\begin{aligned}
2x + y &= 5 \\
4x + 7y &= 11
\end{aligned}
$$
**Egzersiz 2.** 3×3 sistemini eliminasyonla çöz; $E_{21}, E_{31}, E_{32}$ matrislerini yaz; $E = E_{32} E_{31} E_{21}$ çarpımını bul.
$$
A = \begin{pmatrix} 1 & 1 & 1 \\ 2 & 3 & 4 \\ 1 & 0 & 2 \end{pmatrix}, \quad \mathbf{b} = \begin{pmatrix} 6 \\ 20 \\ 8 \end{pmatrix}
$$
**Egzersiz 3.** Hangi $A$ matrisinde eliminasyon başarısız olur ve satır takası da kurtaramaz? En basit 2×2 örneği yaz.
**Egzersiz 4.** *(Python — LU görselleştirme)* Strang'in örneğinde `scipy.linalg.lu` ile $P, L, U$ ayrışımını üret ve pivotları kontrol et.
```{python}
#| label: code-egzersiz-4
#| code-fold: false
import numpy as np
from scipy.linalg import lu
A = np.array([[1, 2, 1], [3, 8, 1], [0, 4, 1]], dtype=float)
b = np.array([2, 12, 2], dtype=float)
x = np.linalg.solve(A, b)
print("x =", x) # [2, 1, -2]
P, L, U_scipy = lu(A)
print("Pivotlar (diag U):", np.diag(U_scipy))
print("P =\n", P)
print("L =\n", L)
print("U =\n", U_scipy)
```
**Egzersiz 5.** Çarpanların işaretlerini değiştirip $E_{ij}^{-1}$ matrislerini ters çevirerek $L = E_{21}^{-1} E_{31}^{-1} E_{32}^{-1}$ matrisini bul (Strang'in 3×3 örneği için). Sonuç alt üçgensel olmalı. **Bu L, LU ayrışımının L'idir.**
## Sonraki Ders İçin Hazırlık {#sec-sonraki}
**Ders 3: Matris Çarpımı ve Ters Matrisler**
- Matris çarpımının dört bakışı: kolon × kolon, satır × satır, hücre, blok.
- Ters matrisin tam tanımı ve Gauss–Jordan ile hesabı.
- $(AB)^{-1} = B^{-1} A^{-1}$ — sıra ters çevriliyor.
::: {.callout-warning title="Ders 3 öncesi yapılacak"}
- Bu dersin egzersizlerini çöz, özellikle **4** (LU görselleştirme) ve **5** (L'i ters eliminasyonla inşa).
- Bu cümleyi içselleştir: *"Eliminasyon $A$'yı $E$ matrisleri ile çarparak $U$'ya dönüştürür: $EA = U$."*
- Python'da `scipy.linalg.lu` ile birkaç farklı matris dene; pivot pozisyonlarını anlamaya çalış.
:::
## Anahtar Kavramlar (Cheat Sheet) {#sec-cheat-sheet}
| Kavram | Tanım | Strang'da |
|--------|-------|-----------|
| **Eliminasyon (Gauss)** | $A$'yı satır işlemleriyle $U$'ya dönüştürme | 0m30 |
| **Pivot** | Her kolonda referans eleman, sıfır olamaz | 4m20 |
| **Çarpan $\ell_{ij}$** | Eliminasyon adımının oranı | 4m50 |
| **Üst üçgensel $U$** | Köşegen altı sıfır olan matris | 9m25 |
| **İleri eliminasyon** | $A \to U$ dönüşümü | 5m18 |
| **Geri yerine koyma** | $U\mathbf{x} = \mathbf{c}$ çözümü, alttan yukarı | 17m50 |
| **Eliminasyon matrisi $E_{ij}$** | $(i,j)$ konumunu sıfırlayan elementer matris | 29m08 |
| **Birleşme yasası** | $A(BC) = (AB)C$ — parantez kaydırılabilir | 35m36 |
| **Permütasyon $P$** | Satır takası matrisi | 37m35 |
| **Ters matris $E^{-1}$** | $E \cdot E^{-1} = I$ | 44m00 |
| **Singular** | Pivotu sıfırlanan ve takasla kurtulmayan matris | 14m00 |
## ML Bağlantıları Özeti {#sec-ml-baglantilar}
::: {.callout-tip title="7 köprü"}
1. **`np.linalg.solve` = Gauss eliminasyonu** → Linear regression normal equations, Newton's method, Kalman filter — hepsi bu rutini çağırır.
2. **LU decomposition (Ders 4)** → Eliminasyonu saklamanın yolu. `torch.linalg.lu_factor` — aynı $A$ için birden çok $\mathbf{b}$ çözüleceğinde cache.
3. **Matris çarpımı sıra önemli** → $AB \neq BA$. Attention'da $QK^T$ vs $K^T Q$ farklı; backprop'ta gradient zincirinde sıra hayati.
4. **Birleşme yasası → Flash Attention** → Aynı sonuç, farklı parantez; HBM erişimi $O(n^2)$'den $O(n)$'a iner.
5. **Partial pivoting → numerik sağlamlık** → Batch/layer norm, $\epsilon$ ile bölme, Cholesky alternatifi — hepsi aynı motivasyon.
6. **Singular matrisler** → Ill-conditioned sistemler, gradient explosion/vanishing, düşük-rank kayıplar; Ders 1'in LoRA hikayesinin numerik versiyonu.
7. **Permütasyon matrisleri $P$** → Token shuffling, batch reordering, dropout maskelerinde implicit $P$.
:::
::: {.callout-important title="Tek bir şey alıp gideceksen"}
**$EA = U$.** Eliminasyon = sol-çarpan $E$ matrislerinin zinciri = $A$'yı üst üçgensel yapma. Bu denklem, sayısal lineer cebirin temel taşı.
:::