diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..a8474e2
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,6 @@
+# Latex-related generated files (in any folder)
+*.aux
+*.log
+*.out
+*.synctex.gz
+*.toc
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..269c6a3
--- /dev/null
+++ b/README.md
@@ -0,0 +1,20 @@
+# Egyetemi jegyzetek
+
+Ebben a repository-ban megtalálhatóak a jobban sikerült egyetemi jegyzeteim, amelyek másoknak esetleg hasznosak lehetnek.
+
+Ezek a jegyzetek nincsenek lektorálva, valószínűleg vannak bennük hibák. Amióta készültek, könnyen lehet, hogy a tananyag is megváltozott.
+
+Ebben a README-ben található egy link minden jegyzethez. A fájlok között navigálva is megtalálhatóak, de ez a README egy kicsit jobban rendszerezi őket.
+
+## ELTE IK Proginf BSc, Szoftvertervező (B) szakirány (kezdés éve: 2020)
+
+| Félév     | Tárgy kódja | Tárgy neve | Link |
+|:---------:|:-----------:|:----------:|:----:|
+| 2021-22-1 | IP-18AA2E/G | Algoritmusok és adatszerkezetek II | [link](algo2/README.md) |
+| 2021-22-1 | IP-18bPREE/G | Programozáselmélet |  [link](progelm/README.md) |
+| 2021-22-1 | IP-18bDM2E/G | Diszkrét matematika II |  [link](dimat2/README.md) |
+| 2021-22-2 | IP-18AB1E/G | Adatbázisok I |  [link](adatb1/README.md) |
+| 2021-22-2 | IP-18OPREG | Operációs rendszerek |  [link](oprend/README.md) |
+| 2021-22-2 | IP-18bFNYFPRE/G | Formális nyelvek és fordítóprogramok alapjai |  [link](fonya-fordprog/README.md) |
+| 2021-22-2 | IP-18bVSZEG | Valószínűségszámítás és statisztika |  [link](valszám-stat/README.md) |
+| 2021-22-2 | IP-18bNM1E/G | Numerikus módszerek I |  [link](nummód1/README.md) |
diff --git a/adatb1/Chase-teszt.png b/adatb1/Chase-teszt.png
new file mode 100644
index 0000000..46d048c
Binary files /dev/null and b/adatb1/Chase-teszt.png differ
diff --git "a/adatb1/EK-aloszt\303\241ly.png" "b/adatb1/EK-aloszt\303\241ly.png"
new file mode 100644
index 0000000..16a524a
Binary files /dev/null and "b/adatb1/EK-aloszt\303\241ly.png" differ
diff --git a/adatb1/EK-gyenge-egyedhalmaz.png b/adatb1/EK-gyenge-egyedhalmaz.png
new file mode 100644
index 0000000..ddc6585
Binary files /dev/null and b/adatb1/EK-gyenge-egyedhalmaz.png differ
diff --git "a/adatb1/EK-kapcsolat-attrib\303\272tum.png" "b/adatb1/EK-kapcsolat-attrib\303\272tum.png"
new file mode 100644
index 0000000..c67ec03
Binary files /dev/null and "b/adatb1/EK-kapcsolat-attrib\303\272tum.png" differ
diff --git a/adatb1/EK-kapcsolat.png b/adatb1/EK-kapcsolat.png
new file mode 100644
index 0000000..2bad366
Binary files /dev/null and b/adatb1/EK-kapcsolat.png differ
diff --git "a/adatb1/EK-rel\303\241ci\303\263v\303\241.png" "b/adatb1/EK-rel\303\241ci\303\263v\303\241.png"
new file mode 100644
index 0000000..ab88b7b
Binary files /dev/null and "b/adatb1/EK-rel\303\241ci\303\263v\303\241.png" differ
diff --git "a/adatb1/FF-geometriai-reprezent\303\241ci\303\263.png" "b/adatb1/FF-geometriai-reprezent\303\241ci\303\263.png"
new file mode 100644
index 0000000..0f34599
Binary files /dev/null and "b/adatb1/FF-geometriai-reprezent\303\241ci\303\263.png" differ
diff --git a/adatb1/README.md b/adatb1/README.md
new file mode 100644
index 0000000..b15a985
--- /dev/null
+++ b/adatb1/README.md
@@ -0,0 +1,7 @@
+**Képzés:** ELTE IK Proginf BSc, Szoftvertervező (B) szakirány (kezdés éve: 2020)  
+**Tárgy neve:** Adatbázisok I  
+**Tárgy kódja:** IP-18AB1E/G
+
+A gyakorlat-specifikus része a jegyzetnek a legvégén található.
+
+[Jegyzet link](adatb1.pdf)
diff --git a/adatb1/adatb1.pdf b/adatb1/adatb1.pdf
new file mode 100644
index 0000000..c108eac
Binary files /dev/null and b/adatb1/adatb1.pdf differ
diff --git a/adatb1/adatb1.tex b/adatb1/adatb1.tex
new file mode 100644
index 0000000..e86491e
--- /dev/null
+++ b/adatb1/adatb1.tex
@@ -0,0 +1,1646 @@
+% !TeX spellcheck = hu_HU
+\documentclass[12pt,a4paper]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{cmap}
+\usepackage[T1]{fontenc}
+\usepackage[magyar]{babel}
+\usepackage{amsmath}
+\usepackage{amsfonts}
+\usepackage{amssymb}
+\usepackage{graphicx}
+
+\usepackage{outlines}
+\usepackage{hyperref}
+
+\hyphenpenalty=10000
+
+\def\ojoin{\setbox0=\hbox{$\bowtie$}%
+  \rule[-.02ex]{.25em}{.4pt}\llap{\rule[\ht0]{.25em}{.4pt}}}
+\def\leftouterjoin{\mathbin{\ojoin\mkern-5.8mu\bowtie}}
+\def\rightouterjoin{\mathbin{\bowtie\mkern-5.8mu\ojoin}}
+\def\fullouterjoin{\mathbin{\ojoin\mkern-5.8mu\bowtie\mkern-5.8mu\ojoin}}
+
+\def\tef{\to\to}
+
+\begin{document}
+
+\begin{center}
+	\huge
+	Adatbázisok I\\
+	\vspace{1mm}
+	\LARGE
+	Előadás és gyakorlat jegyzet\\
+	\vspace{5mm}
+	\large
+	Készült Szalai-Gindl János Márk előadásai\\
+	és Vörös Péter gyakorlatai alapján\\
+	\vspace{5mm}
+	Sárközi Gergő, 2021-22-2. félév\\
+	Nincsen lektorálva!
+\end{center}
+
+\tableofcontents
+
+\pagebreak
+
+\section{Bevezetés}
+
+\begin{outline}
+	\1 Adatbázis: Database Management System által kezelt adatok együttese
+	\1 DBMS feladatai:
+		\2 Adatbázis létrehozása, adatbázis séma definiálása
+		\2 Adatok lekérdezése, módosítása (hatékonyan)
+		\2 Nagyméretű adatok hosszú időn történő tárolása
+		\2 Autentikáció és meghibásodás ellen védelem
+		\2 Egyszerre több felhasználó egyidejű hozzáférésének biztosítása
+	\1 Több adatbázist egy adattárház (middleware) fog össze
+\end{outline}
+
+\section{Relációs adatmodell}
+
+\begin{outline}
+	\1 Adatmodell: információ/adatok leírására szolgáló jelölés
+		\2 Adatok struktúrája
+		\2 Adatokon végezhető műveletek
+		\2 Adatokra vonatkozó megszorítások (pl. unique)
+	\1 Legfontosabb adatmodellek: relációs, félig strukturált (XML)
+	\1 Adatok 2D-s táblákban (relációkban) vannak
+		\2 Egy reláció az sorok halmaza, ennek a halmaznak neve: előfordulás
+		\2 Halmaz $\implies$ nem számít a sorrend, egy sor max egyszer szerepelhet
+	\1 Reláció fejrészében attribútumok vannak
+		\2 Relációséma: attribútumok halmaza; adatelemek adatainak formája
+		\2 attribútumok sorrendje nem fix, nevük alapján hivatkozhatók
+		\2 attribútumok meghatározzák az értékkészletet
+	\1 Adatbázis: relációk halmaza
+	\1 Egy sor elemei: mezők (komponensek)
+		\2 Csak atomi értékeket vehetnek fel: szám, szöveg, referencia, stb.
+\end{outline}
+
+\pagebreak
+
+\section{Relációs algebra}
+
+\begin{outline}
+	\1 Algebra: műveletek és atomi operandusok
+		\2 Eredmény: reláció
+		\2 Operandusok: konstansok, változók (relációkból)
+	\1 Monoton operátor: egy reláción értelmezett operátor akkor monoton, ha bármely argumentumrelációhoz egy újabb sort hozzávéve az eredmény tartalmazza az összes eddigi sort, és esetleg újabbakat is
+\end{outline}
+
+\subsection{Megszorítások}
+
+\begin{outline}
+	\1 Megjegyzés: algebrai műveletek lejjebb vannak, de kellenek ide
+	\1 Relációra vonatkozó megszorítás: $R = \emptyset$ vagy $R \subseteq S$
+		\2 Kifejezőkészségük azonos, pl. $R$ sorai részhalmaza $S$ sorainak
+	\1 Hivatkozási épség megszorítás: ha itt megjelenik, ott is meg kell
+		\2 Kifejezés: $\Pi_A(R) \subseteq \Pi_B(S)$
+	\1 Kulcs: attribútumok halmaza egy kulcs, ha a reláció bármely (mostani és jövőbeli) előfordulásában nincs két olyan sor, amelyek a kulcs összes attribútumának értékein megegyeznek.
+		\2 Példa: (a, b) kulcs: $\sigma_{R.a=S.a \wedge R.b = S.b \wedge R.c \ne S.c}(R\times S) = \emptyset$
+		\2 Aláhúzással jelöljük (általában?)
+\end{outline}
+
+\pagebreak
+
+\subsection{Algebrai műveletek}
+
+\begin{outline}
+	\1 Projekció, vetítés: attribútumok szűkítése, jelölés: $\Pi_{A,B}(R)$
+	\1 Szelekció, kiválasztás: feltétel alapján sorok szűrése
+		\2 Jelölés: $\sigma_{A=a \wedge C=d}(R)$
+		\2 Minden tag 1 vagy 2 attribútumból áll (vagy 2, vagy 1 és 1 konstans)
+		\2 A tagokban ezek a műveletek lehetnek: $=, <, >, \ne, \le, \ge$
+		\2 A tagokat ezek kapcsolhatók: $\lnot, \wedge, \lor$
+	\1 Unió, metszet, különbség
+		\2 Feltétel: operandusok attribútumai megegyeznek
+	\1 Descartes-szorzat, jelölés: $R \times S$
+		\2 Azonos nevű attribútumok a reláció nevét kapják prefixnek
+		\2 Asszociatív (szabadon zárójelezhető), kommutatív (felcserélhető)
+	\1 Átnevezés: $\rho_{S(C,D,E)}(R)$ vagy $\rho_S(R)$
+	\1 Théta-összekapcsolás: $R \bowtie_F S \Leftrightarrow \sigma_F (R \times S)$ \;
+	(ahol $F$ egy feltétel)
+		\2 Példa: $R \bowtie_{R.A = S.A} S$
+		\2 Kommutatív
+		\2 Asszociatív, ha a feltétel nem használ olyan attribútumot, ami a "távolabbi" (csak megfelelő zárjelezés esetén elérhető) relációból származik
+			\3 $E_1 \bowtie_{F_1} (E_2 \bowtie_{F_2} E_3) \equiv (E_1 \bowtie_{F_1} E_2) \bowtie_{F_2} E_3$\\
+			ha $attr(F_1) \subseteq attr(E_1) \cup attr(E_2)$\\
+			és \;$attr(F_2) \subseteq attr(E_2) \cup attr(E_3)$
+	\1 Egyen-összekapcsolás, equi join:
+		\2 Théta-összekapcsolás, ahol egyenlőség a feltétel
+	\1 Természetes összekapcsolás: Théta, F= minden azonos attribútum egyezik
+		\2 Jelölés: $R \bowtie S$
+		\2 Alternatíva: Théta-összekapcsolás, majd közös attribútumokból 1
+		\2 Kommutatív, asszociatív (mindig)
+\end{outline}
+
+\pagebreak
+
+\section{Relációs algebrai lekérdezések optimalizációja}
+
+\begin{outline}
+	\1 Ekvivalens lekérdezések: tetszőleges előfordulás esetén is azonos eredmény
+	\1 Lépések (mindezt egy fán használjuk):
+		\2 Műveletek szétbontása (pl. konjunkció, összekapcsolás)
+			\3 Természetes összekapcsolásból Descartes-szorzat és kiválasztás
+		\2 Műveletek a levélhez közel helyezése (minél előbbre)
+		\2 Projekciók behelyezése (nem szükséges oszlopok levágása)
+			\3 Akkor nagy a nyereség, ha az oszlopok vannak külön-külön fájlban tárolva (nem pedig a sorok)
+			\3 Nem kötelező kiválasztás elé: elég kiválasztás után, de összekapcsolás előtt
+		\2 Természetes és théta összekapcsolásokra cserélni, amit lehet
+	\1 Diszjunkció bonyolultabb, mint a konjunkció
+	\1 Van arra példa, hogy egy kiválasztást először felfelé kell csúsztatni, hogy
+	aztán le lehessen tolni.
+\end{outline}
+
+\subsection{Műveletek optimalizációja}
+
+\begin{outline}
+	\1 Projekció sorozat: $X \subseteq Y \implies \Pi_X(\Pi_Y(E)) \equiv \Pi_X(E)$
+	\1 Kiválasztás és feltételek...
+		\2 konjunkciója: $\sigma_{F1}(\sigma_{F2}(E)) \equiv \sigma_{F1 \wedge F2}(E)$
+		\2 diszjunkciója: $\sigma_{F1}(E) \cup \sigma_{F2}(E) \equiv \sigma_{F1 \lor F2}(E)$
+	\1 Kiválasztás elé projekció beillesztése:\\
+	$Y = attr(F) \cup X \implies \Pi_X(\sigma_F(E)) \equiv \Pi_X(\sigma_F(\Pi_Y(E)))$
+	\1 Kiválasztás és Descartes-szorzat/összekapcsolás:
+		\2 Legyen $\Delta$ vagy $\times$ vagy $\bowtie$
+		\2 Ha $F=F_1 \wedge F_2$ és $attr(F_i) \subseteq attr(E_i)$\\
+		Akkor $\sigma_F(E_1 \Delta E_2) \equiv \sigma_{F_1} (E_1) \Delta \sigma_{F_2} (E_2)$
+		\2 Ha $F=F_1 \wedge F_2$ és $attr(F_1) \subseteq attr(E_1)$ de $attr(F_2) \not \subseteq attr(E_i)$\\
+		Akkor $\sigma_F(E_1 \Delta E_2) \equiv \sigma_{F_2}(\sigma_{F_1} (E_1) \Delta E_2)$
+\pagebreak
+	\1 Projekció és Descartes-szorzat/összekapcsolás:
+		\2 Legyen $\Delta$ vagy $\times$ vagy $\bowtie$
+		\2 Ha $X=Y \cup Z$ és $Y \subseteq attr(E_1)$ és $Z \subseteq attr(E_2)$
+		\2 Akkor $\Pi_X(E_1 \Delta E_2) \equiv \Pi_Y(E_1) \Delta \Pi_Z(E_2)$
+	\1 Kiválasztás és halmazműveletek: disztributív\\
+	Legyen $\Delta$ vagy $\cap$ vagy $\cup$ vagy $\setminus$:
+	$\sigma_F (E_1 \Delta E_2) \equiv \sigma_F(E_1) \Delta \sigma_F(E_2)$
+	\1 Projekció és unió disztributivitás: $\Pi_X(E_1 \cup E_2) \equiv \Pi_X (E_1) \cup \Pi_X (E_2)$
+\end{outline}
+
+\subsection{Optimalizációra példa}
+
+\begin{outline}
+	\1 Feladat: Kik azok a 20 évesek, akik moszkvai kiadású könyvet kölcsönöztek?
+		\2 Személy(név, kor, város, ISBN)
+		\2 Könyv(cím, író, ISBN, ár)
+		\2 Kiad(k-cím, k-író, város, ország)
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.9\linewidth]{relalg-optimize-short}
+\end{figure}
+
+\pagebreak
+
+\section{SQL bevezetés}
+
+\begin{outline}
+	\1 Magas szintű nyelv: "hogyan" helyett "mit"-et írjuk le
+	\1 Adatbázis kezelő optimalizál: kitalálja a leggyorsabb végrehajtási módot
+	\1 Itt már multihalmaz van: lassú mindig kitörölni az ismétlődést
+\end{outline}
+
+\subsection{Lekérdezés jelentése}
+
+\begin{outline}
+	\1 Kezdjük a FROM záradékban megadott relációval
+	\1 Alkalmazzuk a WHERE záradékban megadott kiválasztási feltételt
+	\1 Levetítjük az eredményt a SELECT-ben megadott oszlopokra
+\end{outline}
+
+\subsection{SQL érdekességek}
+
+\begin{outline}
+	\1 SELECT *
+	\1 SELECT név AS sör; SELECT ár*300 AS árForint
+	\1 SELECT 'konstans' as valami (pl. adattárházban integráció miatt)
+	\1 WHERE alapműveletek: AND, OR, NOT, $=,<>,<,>,<=,>=$
+	\1 WHERE attribútum (NOT) LIKE minta
+		\2 Mintában \%: 0 vagy több akármilyen karakter
+		\2 Mintában \_: pontosan egy akármilyen karakter
+		\2 Mintában bármilyen más karakter: önmagát jelenti
+	\1 WHERE attr BETWEEN x AND y (ahol x kötelezően kisebb, mint y)
+	\1 Több táblából lekérdezés: FROM után több tábla
+		\2 Ezután duplikált attribútum nevek neve: TÁBLA.OSZLOP
+	\1 Azonos táblából többször: FROM tábla t1, tábla t2
+	\1 Alapból multihalmaz, ha ne: SELECT DISTINCT
+\end{outline}
+
+\pagebreak
+
+\subsection{NULL értékek}
+
+\begin{outline}
+	\1 Mezők NULL értéket is tartalmazhatnak
+	\1 Lehetséges jelentés: hiányzik, értelmetlen
+	\1 SQL 3 értékű logikát használ: TRUE, FALSE, UNKNOWN
+		\2 Legyen TRUE=1, FALSE=0, UNKNOWN=0.5
+		\2 Ekkor AND=MIN, OR=MAX, NOT(x)=1-x
+	\1 NULL-al hasonlítás (akár NULL-t): eredmény UNKNOWN
+		\2 Helyesen: IS (NOT) NULL
+	\1 Egy sor WHERE-ben UNKNOWN, akkor nem kerül be az eredménybe
+\end{outline}
+
+\subsection{Alkérdések}
+
+\begin{outline}
+	\1 FROM és WHERE záradékban SELECT-FROM-WHERE-t is használhatunk
+		\2 FROM esetén az ideiglenes táblának nevet kell adni általában
+	\1 Egy sort visszaadó alkérdések
+		\2 Konstans értéknek lehet kezelni
+		\2 Általában csak egy oszlopa van
+		\2 Futásidejű hiba keletkezik, ha több sor van
+	\1 Tábla rendes kérdésben és alkérdésben is be van húzva: oszlopnév alapból a legközelebbi FROM-ra vonatkozik (azaz az alkérdésre)
+	\1 Alkérdéses műveltek:
+		\2 Tartalmazás: sor (NOT) IN alkérdés
+		\2 Alkérdés (nem) üres: (NOT) EXISTS alkérdés
+			\3 Korrelált alkérdés: minden sorra külön lefut, mert függ tőlük
+		\2 Halmazműveletek: INTERSECT, UNION, MINUS (=EXCEPT)
+			\3 Nem multihalmaz, hanem halmaz szemtikát halmaz
+			\3 Hogy mégis multihalmaz legyen: <UNION/...> ALL
+		\2 ANY, ALL: pl. x > ANY(alkérdés); x <> ALL(alkérdés)
+\end{outline}
+
+\pagebreak
+
+\subsection{Összekapcsolás (join)}
+
+\begin{outline}
+	\1 Emlékeztető: $NULL \ne NULL$
+	\1 Természetes összekapcsolás: a NATURAL JOIN b
+		\2 SQL optimalizál: nincs SELECT-elve az oszlop $\implies$ nem működik
+		\2 Önmagával: $NULL \ne NULL$, tehát $NULL$-os sorok eltűnnek
+	\1 Descartes-szorzat: a CROSS JOIN b (ugyan az, mint a vessző: a, b)
+	\1 Théta-összekapcsolás: a JOIN b ON aa = bb
+		\2 Ugyan az, mint az INNER JOIN
+		\2 Ugyan az, mint: a, b WHERE aa = bb
+\end{outline}
+
+\section{SQL haladó}
+
+\subsection{Összekapcsolás (join)}
+
+\begin{outline}
+	\1 Félig összekapcsolás (SEMI JOIN, '$\ltimes$'): olyan természetes összekapcsolás, ami csak az első relációból veszi az attribútumokat
+		\2 SELECT R.* FROM R WHERE EXISTS(... R.A = S.A)
+	\1 Anti összekapcsolás (ANTI JOIN, '$\rhd$'): $R \rhd S \equiv R \setminus R \ltimes S$
+		\2 SELECT R.* FROM R WHERE NOT EXISTS(... R.A = S.A)
+	\1 Külső összekapcsolás:
+		\2 SQL-ben: R <típus> (OUTER) JOIN S (ON ...)
+			\3 Típus: LEFT ($\leftouterjoin_C$), RIGHT ($\rightouterjoin_C$), FULL ($\fullouterjoin_C$ or $ _L\bowtie_{R\;C}$)
+			\3 Vagy NATURAL, vagy ON szerepel (vagy semmi): kizáróak
+		\2 Lógó sor: eredmény része, de nincs hozzárendelt sor másik relációban
+			\3 Külső összekapcsolás lényege: ilyen sorokat megőrzi
+			\3 Ilyenkor a hiányzó oszlopok NULL értékű lesznek
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.7\linewidth]{joins}
+\end{figure}
+
+\pagebreak
+
+\subsection{Összesítések (aggregációk)}
+
+\begin{outline}
+	\1 SELECT záradékban alkalmazhatjuk egy-egy oszlopra
+	\1 SUM, AVG, COUNT, MIN, MAX
+	\1 Összesító függvényen belül DISTINCT: COUNT(DISTINCT ár)
+	\1 NULL érték nem számít: mintha nem is lenne ott a sor
+	\1 Üres halmaz eredménye: NULL, kivéve COUNT: ott 0
+	\1 Ha GROUP BY nélkül van: mintha az egész reláció egy csoport lenne
+\end{outline}
+
+\subsection{Csoportosítás (grouping)}
+
+\begin{outline}
+	\1 WHERE utén záradék: GROUP BY oszlop
+	\1 SELECT sör, AVG(ár) FROM x GROUP BY sör;
+	\1 SELECT-ben csak bizonyos dolgok lehetnek:
+		\2 Összesítések, amelyek így csoportonként kiértékelődnek
+		\2 Attribútumok, amik alapján GROUP BY-t csináltunk
+	\1 Csoport szűrés: HAVING ("megfelelője": WHERE)
+		\2 Értelemszerűen meg van szorítva, mint a SELECT 
+\end{outline}
+
+\subsection{Sorba rendezés}
+
+\begin{outline}
+	\1 ORDER BY = ORDER BY ASC; másik: ORDER BY DESC
+\end{outline}
+
+\pagebreak
+
+\subsection{Adatbázis módosítások}
+
+\begin{outline}
+	\1 Nem query: nem ad vissza eredményt
+	\1 Insert, Update, Delete
+	\1 Data Manipulation Language
+\end{outline}
+
+\subsubsection{Beszúrás}
+
+\begin{outline}
+	\1 INSERT INTO <tábla> VALUES (...)
+		\2 Itt minden oszlopnak értéket kell adni
+	\1 Tábla neve után megadhatók az attribútumok:
+		\2 INSERT INTO sör(név, ár) VALUES ('Bud', 100)
+		\2 Így a sorrendet "lokálisan" definiáljuk, nem kell emlékezni
+		\2 A hiányzó attribútumok default (NULL/beállított) értéket kapnak
+	\1 Több sor beszúrása: INSERT INTO <reláció> (alkérdés);
+\end{outline}
+
+\subsubsection{Törlés}
+
+\begin{outline}
+	\1 DELETE FROM <reláció> (WHERE ...)
+	\1 Nincs WHERE: összes sor törlése
+		\2 Alternatíva: TRUNCATE TABLE <név> (ez séma módosítás féleség)
+	\1 Két lépésben hajtódik végre:
+		\2 Először törlendő sorok kijelölése, majd kijelölt sorok kitörlése
+		\2 Emiatt determinisztikus: nem számít melyik tűnik el előbb
+\end{outline}
+
+\subsubsection{Módosítás}
+
+\begin{outline}
+	\1 UPDATE <reláció> SET oszlop1=v1, oszlop2=v2, ... [WHERE ...]
+\end{outline}
+
+\pagebreak
+
+\subsection{Adatbázis sémák}
+
+\begin{outline}
+	\1 Data Definition Language
+	\1 Létrehozás: CREATE TABLE <név> (<elemek, megszorítás listája>);
+		\2 Elem: <név> <típus> [sor megszorítás] [DEFAULT <érték>]
+		\2 Megszorítás: CONSTRAINT <név\_FK> <FK szintaxis lejebb>
+	\1 Törlés: DROP TABLE <név>;
+\end{outline}
+
+\subsubsection{Típusok}
+
+\begin{outline}
+	\1 Szám: INT=INTEGER, REAL=FLOAT
+		\2 Tizedesvessző: . (pont)
+	\1 Szöveg: CHAR(n) (mindig n), VARCHAR(n) (legfeljebb n)
+		\2 VARCHAR2(n): Oracle valami, $\sim$ VARCHAR
+		\2 Aposztrófok közé kell rakni
+		\2 Két aposztróf = egy igazi aposztróf (escape)
+	\1 DATE, megadás: DATE 'yyyy-mm-dd'
+		\2 Gyakon megadás: TO\_DATE('2000.01.01', 'YYYY.MM.DD')
+	\1 TIME, megadás: TIME 'hh:mm:ss' vagy TIME 'hh:mm:ss.tizedmp'
+\end{outline}
+
+\subsubsection{Tábla módosítás}
+
+\begin{outline}
+	\1 ALTER TABLE <név> ....
+		\2 DROP COLUMN/CONSTRAINT <név>
+		\2 ADD <név> <típus> [megszorítások, stb]
+		\2 MODIFY <meglévő név> <új típus> [megszorítások, stb]
+	\1 Oszlopot nem lehet töröli, ha van hozzá CONSTRAINT
+\end{outline}
+
+\pagebreak
+
+\subsection{Megszorítások}
+
+\begin{outline}
+	\1 Adatelemek közötti kapcsolat
+	\1 Adatbázis rendszer tartja fel őket
+	\1 Relációs algebrában: egy lekérdezés értéke legyen pl. üres vagy részhalmaz
+	\1 Gyakori megszorítás: NOT NULL
+\end{outline}
+
+\subsubsection{Kulcsok}
+
+\begin{outline}
+	\1 Attribútum vagy attribútum lista lehet kulcs
+		\2 Egy esetén: create table-ben, attribútum sora végén is lehet
+		\2 Több esetén: csak az attribútum lista után lehet
+	\1 Relációnak nem lehet két sora, amiben megegyeznek
+	\1 PRIMARY KEY vagy UNIQUE
+		\2 PRIMARY KEY-ből csak 1db lehet, nem lehet NULL
+		\2 UNIQUE-ból több is lehet, lehet NULL
+	\1 Oracle SQL: nincs AUTO INCREMENT, helyette hack:\\
+	INSERT INTO x(y) VALUES ((SELECT MAX(y)+1 FROM x))
+\end{outline}
+
+\subsubsection{Idegen kulcsok, hivatkozási épség megszorítás}
+
+\begin{outline}
+	\1 Relációs algebrában: $\Pi_{beer}(Serve) \subseteq \Pi_{name}(Beer)$
+	\1 Megadható attribútum után vagy séma végén
+		\2 név típus REFERENCES reláció(attribútum)
+		\2 FOREIGN KEY (attribútumok...) REFERENCES reláció (attribútumok...)
+	\1 Csak kulcs (PRIMARY KEY / UNIQUE) attribútumokon működik
+	\1 Sértheti: beszúrás vagy a másik oldalon törlés/módosítás
+		\2 Rossz beszúrást csak egyféleképpen kezel az SQL: nem engedi
+		\2 Rossz törlés/módosítás kezelése:
+			\3 Default: szerintem ezt jelenti: nem engedi a módosítást (RESTRICT)
+			\3 Továbbgyűrűzés: másik táblában is töröljük/módosítjuk sor(ok)at
+			\3 Set NULL: másik táblában NULL értéket kap
+			\3 ... KEY ... ON [UPDATE/DELETE] [SET NULL / CASCADE]
+\end{outline}
+
+\pagebreak
+
+\subsubsection{Attribútum alapú (érték-alapú) megszorítás}
+
+\begin{outline}
+	\1 Egy adott oszlopra vonatkozik a megszorítás, annak értékeit ellenőrzi
+	\1 Csak beszúrásnál, módosításnál van végrehajtva
+		\2 Azaz törlésnél nem
+		\2 Azaz foreign-key féle koncepció nincsen
+	\1 Megadás: attribútum után CHECK(feltétel)
+		\2 Alapból csak a saját attribútumra hivatkozhatunk
+		\2 Alkérdés segítségével bármi hivatkozható
+\end{outline}
+
+\subsubsection{Sor-alapú megszorítás}
+
+\begin{outline}
+	\1 Sor mezei közötti kapcsolatot definiál
+	\1 Csak beszúrásnál és módosításnál van végrehajtva
+	\1 Megadás: reláció séma után CHECK(feltétel)
+		\2 Saját relációban bármelyik attribútumra hivatkozhatunk
+		\2 Alkérdés segítségével bármilyen reláció hivatkozható
+\end{outline}
+
+\subsubsection{Globális megszorítás}
+
+\begin{outline}
+	\1 Adatbázissémához tartozik (nem pedig relációhoz)
+	\1 Bármira hivatkozhat (tetszőleges tábla, tetszőleges oszlop)
+	\1 Minden módosítás előtt (insert, update, delete) ellenőrizve van
+		\2 Adatbázis rendszer optimalizálhat: nem nézi meg mindig
+	\1 CREATE ASSERTION név CHECK (feltétel)
+\end{outline}
+
+\pagebreak
+
+\subsection{Trigger}
+
+\begin{outline}
+	\1 Kód végrehajtódik, amikor egy esemény történik (pl. sor beszúrása)
+	\1 Más név: ECA szabály (event-condition-action)
+	\1 Példa: beszúrás visszautasítása helyett (foregin key miatt), beszúrhatunk egy sort a másik táblába is automatikusan (pl. NULL értékkel kiegészítve)
+	\1 CREATE TRIGGER név ... (nagyon sok lehetőség van)
+	\begin{verbatim}
+		CREATE TRIGGER SörTrig
+		BEFORE INSERT ON Felszolgál
+		REFERENCING NEW ROW AS ÚjSor
+		FOR EACH ROW
+		WHEN (ÚjSor.sör NOT IN (SELECT név FROM Sörök))
+		INSERT INTO Sörök(név) VALUES(ÚjSor.sör);
+	\end{verbatim}
+\end{outline}
+
+\pagebreak
+
+\subsection{Tranzakciók}
+
+\begin{outline}
+	\1 Egység, amit osztatlanul kell végrehajtani
+	\1 Lehet lekérdezés és/vagy módosítás
+	\1 Minden SQL utasítás az: 1 elemes tranzakció
+	\1 Perzisztálni kell: végrehajtás közben rendszerhiba $\implies$ ne legyen baj
+	\1 Részei:
+		\2 Konkurenciakezelő: atomicitás megvalósítása, versenyhelyzetek kizárása
+		\2 Naplózás- és helyreállítás-kezelés: tranzakciók tartóssága (perzisztencia)
+	\1 Műveletek végrehajtási sorrendje fontos (race condition)
+	\1 Valamilyen szinten párhuzamosítva van
+\end{outline}
+
+\subsubsection{ACID tranzakciók}
+
+\begin{outline}
+	\1 Atomicity: vagy az összes, vagy semelyik utasítás hajtódik végre
+	\1 Consistency: adatbázis megszorítások megőrződnek
+	\1 Isolation: úgy tűnik, mintha a folyamatok egymás után futnának le
+	\1 Durability: befejeződött tranzakció módosításai nem vesznek el
+	\1 Opcionálisan gyengébb feltételek is megadhatóak
+		\2 pl. osztott adatbázisoknál kötelező
+\end{outline}
+
+\subsubsection{SQL utasítások}
+
+\begin{outline}
+	\1 COMMIT: tranzakció módosításai megőrződnek
+	\1 ROLLBACK: tranzakció abortál, összes utasítás vissza van görgetve
+		\2 0-val való osztás, stb. automatikus ezt eredményezi
+\end{outline}
+
+\pagebreak
+
+\subsubsection{Elkülönítési szintek}
+
+\begin{outline}
+	\1 Egy tranzakció milyen állapotot láthat (részeredmények, stb.)
+	\1 Négy elkülönítési szint (ACID-ban I betű finomhangolása)
+	\1 SET TRANSACTION ISOLATION LEVEL <level>
+		\2 A pillatnyi connection-re állítja be
+	\1 SERIALIZABLE (magyarul: sorbarendezhető)
+		\2 Tranzakciók nem befolyásolják egymást, nincs átfedés.
+	\1 REPEATABLE READ
+		\2 Csak COMMIT-olt adatot látni, külön-külön olvasásoknál extra sorok megjelenhetnek (ha közben van módosítás). Sorok soha nem módosulhatnak, nem tűnhetnek el.
+		\2 Többletsor neve: fantomsor, fantomadat.
+	\1 READ COMMITTED
+		\2 Csak COMMIT-olt adatot látni, de a tranzakción belül minden művelet lehet, hogy más adaton dolgozik: közben lehet módosítás.
+		\2 "Nem ismételhető olvasás"
+	\1 READ UNCOMMITTED
+		\2 A nem COMMIT-olt változtatásokat is látja (piszkos adatokat)
+\end{outline}
+
+\pagebreak
+
+\subsection{Nézettáblák}
+
+\begin{outline}
+	\1 Nézettáblát alaptáblákból és más nézettáblákból definiáljuk
+	\1 Virtuális nézettábla: nem tárolódik adat, csak a relációt megadó lekérdezés
+	\1 Materializált nézettábla: maga az adat tárolódik
+		\2 Ha sokat lekérdezzük a nézettáblát, akkor gyorsabb lehet
+		\2 Minden módosítás esetén frissül automatikusan, ami idő
+			\3 Beállítható: X időn belül vagy periodikus frissítés
+			\3 Azaz nem kötelező a legfrissebb adatnak benne lennie
+		\2 Előnye új táblához képest:
+			\3 Adatbáziskezelő helyettünk frissíti
+			\3 Lekérdezés optimalizáció akár ki tudja használni ezeket a táblákat
+	\1 CREATE (MATERIALIZED) VIEW <név> AS <lekérdezés>
+	\1 Állítólag pár egyszerű módosítást nézettáblán keresztül is lehet csinálni
+	\1 NEM nézettábla, hanem másolás: CREATE TABLE <név> AS <lekérdezés>
+\end{outline}
+
+\subsection{Indexek}
+
+\begin{outline}
+	\1 Adatszerkezet, amivel egy-egy relációt gyorsabban lekérdezhetünk egy/több attribútum alapján
+	\1 Megvalósítás lehet hash table, de általában bináris fa
+	\1 SQL-ben deklarálás
+		\2 Nincs szabvány/standard megoldás
+		\2 CREATE INDEX <IndexNév> ON Tábla(Oszlop)
+		\2 CREATE INDEX <IndexNév> ON Tábla(Oszlop1, Oszlop2, ...)
+	\1 Használatuk: automatikus, csak a megfelelő attribútum alapján szűrjünk
+	\1 Hangolás: indexek bevezetése gyorsíthat, de nem feltétlenül jó
+		\2 Indexek mellett: felgyorsítja a lekérdezéseket
+		\2 Indexek ellen: módosítások lassulnak; indexeket is frissíteni kell
+		\2 Menete: query load $\implies$ indexek készítése $\implies$ hatás vizsgálata
+\end{outline}
+
+\pagebreak
+
+\section{SQL jogosultságkezelés}
+
+\begin{outline}
+	\1 9 féle jogosultság van, némelyik oszlop szinten is megadható
+	\1 Pár relációra vonatkozó jogosultság:
+		\2 SELECT (lehet, hogy csak adott attribútumra vonatkozik)
+		\2 INSERT (lehet, hogy csak adott attribútumra vonatkozik)
+		\2 DELETE
+		\2 UPDATE (lehet, hogy csak adott attribútumra vonatkozik)
+	\1 Jogosultságokat lehet adni még:
+		\2 Nézettábla (virtuális és materializált) lekérdezés/módosítás
+		\2 Relációhoz index, trigger, nézettábla létrehozása
+	\1 Jogosultsági azonosító (authorization ID)
+		\2 Általában a bejelentkezési név
+		\2 Egy másik: PUBLIC
+	\1 Jogosultságok megadása
+		\2 Általunk létrehozott dolgokra minden jogunk megvan
+		\2 GRANT <jogosultságok...> ON <reláció/valami> TO <JogAzonosítók...>
+		\2 ... WITH GRANT OPTION: jogosultságot kapó tovább is adhatja
+	\1 Jogosultságok visszavonása
+		\2 REVOKE <jogosultságok...> ON <reláció/valami> FROM <JogAzonosítók...>
+		\2 Több helyről kapták a jogot $\implies$ megmaradhat utána is
+		\2 REVOKE-hoz meg kell adni egyet:
+			\3 CASCADE: a továbbadott jogosultságokat is megvonjuk
+			\3 RESTRICT: addig nem működik a REVOKE, amíg érvényben van még továbbadott jog
+		\2 REVOKE GRANT OPTION ... is létezik
+\end{outline}
+
+\pagebreak
+
+\subsection{Grant diagrammok}
+
+\begin{outline}
+	\1 Jogosultság gráf
+	\1 Pontok: felhasználó/jogosultság/grant option-e/tuladonos-e
+		\2 Külön pontnak számít: UPDATE ON R és UPDATE ON R(a)
+		\2 AP nevű pont: A azonosítójú P jogát jelenti
+		\2 AP*: P-hez van grant jog
+		\2 AP**: tulajdonosságból származik a jog
+	\1 $X \to Y$ él: X pontot használtuk Y megadására
+	\1 Alapvető szabály:
+		\2 Legyen C és X felhasználó (akár azonos)
+		\2 Legyen Q egy jogosultság, amit P magába foglal (akár azonos)
+		\2 C-nek addig van joga Q-hoz, amíg vezet XP**-ból az egyikbe út:\\
+		CQ, CQ*, CQ**
+	\1 Gráf frissítéskor: pont nem érhető el egy **-ból se $\implies$ törölni kell
+\end{outline}
+
+\pagebreak
+
+\section{Relációs adatbázis tervezés}
+
+\begin{outline}
+	\1 Minden adat egyetlen relációban: kényelmes, de sok a felesleges adat
+		\2 Rossz tárolási hatékonyság
+		\2 Ellentmondásossá válhat (nem változtatjuk meg mindenhol az adatot)
+	\1 Jobb megoldás: felhasználói eset fogalmait, kapcsolatait modellezni kell
+	\1 Jelölés: X,Y,Z attribútum halmaz; A,B,C pedig attribútum
+\end{outline}
+
+\subsection{Kulcsok}
+
+\begin{outline}
+	\1 K szuperkulcs R relációra, ha K funkcionálisan meghatározza R attribútumait
+	\1 K kulcs R-en, ha K szuperkulcs, de egyetlen valódi részhalmaza sem az
+	\1 Azaz például $user\_id,address$ szuperkulcs, de $user\_id$ kulcs
+	\1 Kulcs megkapása: paraszti ésszel vagy FF-ek alapján következtetjük ki
+\end{outline}
+
+\subsection{Funkcionális függőségek (FF)}
+
+\begin{outline}
+	\1 Redundancia: egy/több oszlopból ki tudunk következtetni egy harmadikat
+	\1 Funkcionális függőség ($X \to Y$): ha két sor megegyezik $X$ összes attribútumán, akkor $Y$-jain is
+	\1 Jobboldalak szétvágása (ff): $X \to A_1A_2... \Leftrightarrow X \to A_1 \wedge X \to A_2 \wedge ...$
+\end{outline}
+
+\subsubsection{Armstrong-axiómák 1}
+
+\begin{outline}
+	\1 Reflexivitás: ha $Y \subseteq X \subseteq R$ akkor $X \to Y$ (triviális függőség)
+	\1 Bővítés: $X \to Y$ akkor tetszőleges $Z \subseteq R$ esetén $XZ \to YZ$
+	\1 Tranzitivitás: $X \to Y \wedge Y \to Z \implies X \to Z$
+	\1 Felhasználás példa:
+		\2 Feladat: ha $X \to Y$ és $XY \to Z$ akkor $X \to Z$
+		\2 $X \to Y$ bővítés után $X \to XY$
+		\2 $X \to XY$ és $XY \to Z$ reflexivitás miatt $X \to Z$
+\end{outline}
+
+\pagebreak
+
+\subsubsection{Lezárás}
+
+\begin{outline}
+	\1 Y lezártja ($Y^+$): attribútum halmaz, ami következik $Y$-ból
+		\2 Azaz: $\forall A \in Y^+: Y \to A$
+	\1 Ha Y szuperkulcs, akkor $Y^+$ az összes attribútum lesz
+	\1 Kiszámítás: iteratívan
+		\2 Első lépés: $Y^+ = Y$
+		\2 Indukció: ha $X \subseteq Y^+$ és $X \to A$, akkor $A$-t belerakjuk $Y^+$-ba
+		\2 Iteráció vége: ha utolsó lépésben $Y^+$ nem változott
+	\1 Bizonyítás: $B \in Y^+ \implies Y \to B$
+		\2 Indukcióval (valószínűleg nem kéri számon)
+	\1 Bizonyítás: nem lett egy $B$ sem kihagyva
+		\2 Indirekt módon (valószínűleg nem kéri számon)
+\end{outline}
+
+\subsubsection{Összes következmény FF, szétbontás, FF projekció}
+
+\begin{outline}
+	\1 Motiváció: egy relációsémát több sémára bontunk
+	\1 Ha tudunk attribútumokat és FF-eket, akkor az attribútumok részhalmazán milyen FF-ek lesznek? (normalizálás)
+	\1 Példa: eredeti: $AB \to C, C \to D, D \to A$\\
+	ABC részhalmazon teljesül: $AB \to C$ és $C \to A$
+	\1 Exponenciális algoritmus:
+		\2 Minden lehetséges X halmazhoz számítsuk ki $X^+$-ot
+		\2 Függőségekhez adjuk hozzá $\forall X \to A$-t, ahol $A \in X^+ \setminus X$
+		\2 Dobjuk ki $XY \to A$-t, ha $X \to A$ is teljesül
+		\2 Végül csak azokat az FF-eket nézzük, amikben csak a projektált attribútumok vannak
+		\2 Trükk: $\emptyset^+ = \emptyset$ és $R^+ = R$
+		\2 Trükk: $X^+ = R \wedge X \subseteq Y \implies Y^+ = R$
+\end{outline}
+
+\pagebreak
+
+\subsubsection{FF-ek geometriaia reprezentációja}
+
+\begin{outline}
+	\1 Minden pont egy lehetséges előfordulás (olyan sorhalmaz, ami létezhetne)
+	\1 Minden FF egy régió: előfordulások részhalmaza, amire igaz
+	\1 Triviális FF: a régió a teljes tér
+	\1 Több FF is teljesül: régiók metszete
+	\1 Legyen $A \to B$ és $B \to C$. Ekkor az $A \to C$ régi tartalmazza a két másik régió metszetét, de bővebb nála (valódi tartalmazás, nem egyenlőség).
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.5\linewidth]{FF-geometriai-reprezentáció}
+\end{figure}
+
+\pagebreak
+
+\subsection{Relációs sémák tervezése}
+
+\subsubsection{Relációk felbontása}
+
+\begin{outline}
+	\1 Bemenet: $R(A_1,...,A_n)$; kimenet: $S(B_1,...,B_m),T(C_1,...,C_k)$ relációk
+		\2 $\{A_1,...,A_n\} = \{B_1,...,B_m\} \cup \{C_1,...,C_k\}$
+		\2 $S = \Pi_{B1,...,Bm}(R)$ és $T=\Pi_{C1,...,Ck}(R)$
+	\1 Cél: veszteségmentes felbontás: $r = \Pi_{R1}(r) \bowtie ... \bowtie \Pi_{Rk}(r)$
+		\2 $r$: egy $R$ sémájú reláció
+		\2 $\Pi_{Ri}(r)$: $r$ sorai az $Ri$ attribútumaira (több van!) projektálva
+		\2 Példa nem veszteségmentesre: $ABC$-t $AB$-re és $BC$-re bontjuk,\\
+		de $B$ oszlop minden eleme azonos, $A$ és $C$ elemei viszont nem
+	\1 Cél: funkcionális függőségek megőrzése
+		\2 Nem mindig sikerül
+	\1 Cél: redundancia, anomáliák (felsorolva alul) megszüntetése
+		\2 (Nem mindig sikerül)
+		\2 Módosítási: nem mindenhol módosul az adat (redundancia miatt)
+		\2 Törlési anomália: olyan is törlődik, aminek nem kéne\\
+		pl. ha senki nem szeret egy sört, akkor tudjuk, hogy ki gyártja?
+		\2 Beszúrási: nem tudunk beszúrni, mert olyan adatot kéne megadni, ami nincs értelmezve egy adott esetben (pl. kedvenc söre anyámnak)
+\end{outline}
+
+\pagebreak
+
+\subsubsection{Boyce-Codd normálforma (BCNF)}
+
+\begin{outline}
+	\1 $R$ reláció BCNF formában van, ha $\forall X \to Y$ nemtriv FF-re $X$ szuperkulcs
+		\2 Nemtriviális: $Y$ nem része $X$-nek
+		\2 Szuperkulcs: tartalmaz kulcsot (akár ő maga egy kulcs)
+	\1 Veszteségmentes, de FF-ek nem feltétlenül őrződnek meg, de FF-ek okozta anomália nem lehet benne
+	\1 BCNF-re való felbontás
+		\2 Legyen $R$ reláció, $F$ FF-ek halmaza
+		\2 Van-e olyan $X \to Y$ FF, ami sérti a BCNF-et?
+			\3 Elég $F$-et végignézni: ha $F^+$-ban valami sérti, akkor $F$-ben is
+			\3 Hogyan: $X^+$-ban nincs minden attribútum $\implies$ nem szuperkulcs
+		\2 $R$ dekomponálása $X \to Y$ alapján
+			\3 $R_1 = X^+$ és $R_2 = R - (X^+ - X)$
+			\3 Projektáljuk $F$-beli FF-eket a két új relációra
+			\3 Példa ($F$: név $\to$ cím, név $\to$ kedvenc, kedvelt $\to$ gyártó)
+				\4 Bemenet: Főnökök(név, cím, kedveltSörök, gyártó, kedvenc)
+				\4 név $\to$ cím: R1(név, cím, kedvenc) R2(név, kedvelt, gyártó)
+				\4 Ez még mindig nem BCNF: $R2$-t ketté kell szedni
+	\1 Belátása, hogy a BCNF-re való felbontás veszteségmentes
+		\2 Tranzitivitás féleség: ha $R_1,...,R_k$ egy veszteségmentes felbontása $R$-nek,
+		és $S_1,S_2$ egy veszteségmentes felbontása $R_1$-nek,
+		akkor $S_1,S_2,R_2,...,R_k$ egy veszteségmentes felbontása $R$-nek
+		\2 Tehát csak azt kell belátni, hogy a dekomponálás veszteségmentes
+		\2 Ez pedig triviális (legalábbis az EA diákon ez a magyarázat)
+\end{outline}
+
+\pagebreak
+
+\subsubsection{Chase-teszt vesztességmentességhez}
+
+\begin{outline}
+	\1 Megmondja, hogy veszteségmentes-e egy felbontás
+	\1 Példa eset:
+		\2 Eredeti reláció: $R(A,B,C,D)$
+		\2 FF-ek: $F = \{A \to B, B \to C, CD \to A\}$
+		\2 Felbontás: $R_1(A,D)$, $R_2(A,C)$, $R_3(B,C,D)$
+	\1 Egy táblázatot használ az algoritmus:
+		\2 Oszlopok az eredeti $R$ oszlopai
+		\2 Sorok: minden $R_i$-hez egy sor
+		\2 Cellák: oszlop $R_i$ része akkor ismert ($x$) egyébként ismeretlen ($x_i$)
+	\1 A cél az általános sor ($a,b,c,d$) kialakítása. Az FF-ek használjuk fel.
+		\2 Két egyenlővé teendő szimbólum közül...
+			\3 Egyik index nélküli: másik is azt az értéket kapja
+			\3 Mindkét indexes: a kisebbik indexet kapja mindkettő
+		\2 A lecserélt szimbólum minden előfordulását le kell cserélni
+	\1 Egyszer nem feltétlenül elég végigmenni az FF-eken: tetszőleges sorrendben vettük végig őket, ami lehet, hogy nem optimális. Addig kell újra-újra lefuttatni az "algoritmust", amíg változik az eredmény.
+		\2 Ha megkaptuk az általános sort, akkor biztosan veszteségmentes.\\
+		Ismételni csak akkor kell, ha nem kaptuk meg.
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.7\linewidth]{Chase-teszt}
+\end{figure}
+
+\pagebreak
+
+\subsubsection{Minimális bázis}
+
+\begin{outline}
+	\1 Bázis: $F$-fel ekvivalens FF halmaz
+	\1 Minimális bázis
+		\2 Jobb oldalon mindig csak egy attribútum van
+		\2 Bármely függőség elhagyása esetén már nem bázis
+		\2 Bármely bal oldal csökkentése esetén már nem bázis
+	\1 Minimális bázis létrehozása algoritmikusan: (legyen $F$ az FF-ek halmaza)
+		\2 Kezdetben $G = \emptyset$
+		\2 Függőségek $X \to A$ alakra hozása (jobboldalak szétvágása):\\
+		$\forall \; X \to Y \in F, \; A \in Y \setminus X:$ az $X \to A$ FF-eket tegyük $G$-be
+		\2 Nem szükséges függőségek elhagyása:\\
+		$X \to A \in G$ elhagyása, ha $X \to A$ következik $(G \setminus \{X \to A\})$-ból
+		\2 Baloldalak minimalizálása:\\
+		Ha $X \to A \in G$ és $\exists B \in X: A \in (X \setminus \{B\})^+$ ($G$ szerint),
+		azaz $G$ ekvivalens marad: $G$-ben $X \to A$ lecserélése $(X \setminus \{B\}) \to A$-ra
+\end{outline}
+
+\subsubsection{Harmadik normálforma (3NF)}
+
+\begin{outline}
+	\1 Motiváció: BCNF felbontáskor veszíthetünk el függőségeket
+		\2 Példa: AC,BC sémákkal nem lehet az $AB \to C$ egy FF
+	\1 Veszteségmentes, megőrzi az FF-eket, de anomália maradhat
+	\1 Prím (elsődleges) attribútum: legalább egy kulcsnak az eleme
+	\1 Definíció: $X \to A$ nem triviális FF csak akkor sérti meg 3NF-et, ha $X$ nem szuperkulcs és $A$ nem prím
+		\2 BCNF-től eltérés: FF akkor is szabályos, ha jobboldal prím
+	\1 Minimális bázisból 3NF-re bontás
+		\2 Minimális bázis minden FF-jének bal- és jobboldalának uniója egy séma,
+		pl.: $X \to A$ esetén XA egy séma
+		\2 Ha az így kapott sémák között nincs szuperkulcs, akkor egy extra séma:
+		valami, ami egy kulcs az R reláción
+			\3 Ez a veszteségmentességhez kell
+	\1 Helyesség belátása:
+		\2 Függőségeket megőrizni a minimális bázis miatt
+		\2 Veszteségmentes, amit a Chase-tesztel be lehet látni
+\end{outline}
+
+\subsection{Többértékű függőségek}
+
+\subsubsection{Többértékű függőség (TÉF)}
+
+\begin{outline}
+	\1 Jelölés: $X \tef Y$
+	\1 $X$ minden értékei esetén $Y$ értékei függetlenek az $R \setminus X \setminus Y$ értékeitől
+		\2 Azaz ha két sorban $X$ értékei egyeznek $\implies$ $Y$ értékei felcserélhetők
+	\1 Példa: Alkesz(név, tel, kedveltSör): telefonszám független a sörtől
+		\2 név $\tef$ tel és név $\tef$ kedveltSör
+		\2 Azaz egy adott névhez tartozó telefonok, sörök minden kombinációja létezik a sorok között
+	\1 Triviális TÉF: $X \tef Y$ ahol $Y \subseteq X$ vagy $X \cup Y = R$ \;\; ($X,Y \subseteq R$)
+\end{outline}
+
+\subsubsection{Többértékű függőség szabályok}
+
+\begin{outline}
+	\1 Minden FF egyben TÉF: $X \to Y \implies X \tef Y$
+		\2 Ha két sor egyezik $X$-en, akkor $Y$-on; felcserélve ugyan azt kapjuk
+	\1 Komplementálás: $X \tef Y \implies X \tef (R \setminus X \setminus Y)$
+		\2 $X$ megegyezik, akkor mindegy: $Y$-t cseréljük fel / minden mást
+	\1 FF-ekkel ellentétben a jobboldalak nem darabolhatók szabadon
+	\1 Bővíthetőség: ha $X \tef Y$ és $V \subseteq W$ akkor $XW \tef YV$
+	\1 Tranzitivitás: $X \tef Y \wedge Y \tef S \implies X \tef S \setminus Y$
+\end{outline}
+
+\pagebreak
+
+\subsubsection{Negyedik normálforma (4NF)}
+
+\begin{outline}
+	\1 Motiváció: TÉF-ek okozta redundanciát BCNF nem szünteti meg
+	\1 4NF: TÉF-eket dekomponáláskor FF-ként kezeljük\\
+	(kulcs kereséskor a TÉF-ek nem számítanak)
+	\1 $R$ akkor van 4NF-ben, ha $\forall$ nemtriv. $X \tef Y$ esetén $X$ szuperkulcs
+	\1 $R$ 4NF-ben van $\implies$ BCNF-ben is (fordítva nem igaz)
+		\2 Minden FF, ami BCNF-et megsérti, az a 4NF-et is megsérti
+	\1 4NF dekompozíció, ha $X \tef Y$ sérti 4NF-et: (hasonló BCNF-hez)\\
+	$R_1 = XY$ és $R_2 = R \setminus (Y \setminus X)$
+\end{outline}
+
+\subsubsection{TÉF-ek és FF-ek együttes következtetése}
+
+\begin{outline}
+	\1 Feladat: egy TÉF, FF halmazból következik-e egy adott TÉF/FF?
+	\1 Megoldás: tabló, Chase ötlet kiterjesztése
+	\1 Chase-teszt kiterjesztése
+	\1 TÉF esetén írjuk be a szükséges sorokat, hogy a TÉF igaz legyen
+	\1 Vagy ha $X \tef Y$ bizonyítása a feladat, akkor kezdjünk 2 $X$-ben egyező és $R \setminus X$-ben különböző sorral és lássuk be (FF-ek és TÉF-ek segítségével), hogy a két sor megegyezik
+	\1 Nem sikerült felfognom a példák levezetését, így ezen témakör jegyzete hiányos.
+\end{outline}
+
+\pagebreak
+
+\section{Egyed-kapcsolat modell, E/K diagram}
+
+\subsection{Cél, motiváció}
+
+\begin{outline}
+	\1 Adatbázisséma felvázolása
+	\1 Később relációs adatbázissémává alakítható
+	\1 Tervezést segíti (főbb részek felvázolása)
+\end{outline}
+
+\subsection{Alafogalmak}
+
+\begin{outline}
+	\1 Egyed
+	\1 Egyedhalmaz (téglalap): mint OOP-ben egy osztály
+		\2 Csak struktúrát tekintünk, végezhető műveleteket nem
+		\2 Értéke: hozzá tartozó egyedek halmaza
+	\1 Attribútum (ovális): atomi érték (szám, szöveg) (tömb/rekord NEM!)
+		\2 Össze vannak kötve egyedhalmazzal
+	\1 Kapcsolat (rombusz): 2 (bináris) vagy több egyedhalmazt köt össze
+		\2 Értéke a kapcsolathalmaz: sorok halmaza, minden sorban a kapcsolatban résztvevő egyedhalmazokból van 1-1 darab
+\end{outline}
+
+\pagebreak
+
+\subsection{Kapcsolatokról bővebben}
+
+\subsubsection{Kapcsolatok típusai}
+
+\begin{outline}
+	\1 Általában bináris kapcsolatról beszélünk most
+	\1 Sok-sok: mindkét adathalmaz egyedei 0/1/sok másik egyedhez kapcsolódhatnak
+		\2 Jelölése: sima vonal
+	\1 Sok-egy: (jelölése: "egy" oldalon háromszög nyíl van)
+		\2 Első egyedhalmaz minden eleme legfeljebb egyhez kapcsolódnak
+		\2 Második egyedhalmaz elemei 0, 1 vagy több egyedhez kapcsolódhatnak
+	\1 Egy-egy: minden entitáns legfeljebb egy másikhoz kapcsolódik
+		\2 Jelölése: mindkét végén háromszög nyíl
+	\1 "Legfeljebb" helyett "pontosan" egy: lekerekített nyíl ($-\triangleright$ helyett $\to$)
+	\1 Alternatív jelölés: él címkézése [a,b] intervallummal (sok=n)
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.5\linewidth]{EK-kapcsolat}
+\end{figure}
+
+\subsubsection{Kapcsolatok attribútumai}
+
+\begin{outline}
+	\1 Az attribútum a kapcsolatban álló egyedhalmazok együttes tulajdonsága
+	\1 Jelölés: simán hozzákötünk egy attribútumot a kapcsolathoz
+	\1 Alternatív jelölés: egyedhalmaz bevezetése és vastag háromszöges nyíllal rámutatunk a kapcsolatból
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.45\linewidth]{EK-kapcsolat-attribútum}
+\end{figure}
+
+\subsubsection{Kapcsolat szerepek}
+
+\begin{outline}
+	\1 Szerep: felcímkézett él
+	\1 Szükséges, ha egy egyedhalmaz többszörös tagja kapcsolatnak
+\end{outline}
+
+\pagebreak
+
+\subsection{Egyedhalmazokról bővebben}
+
+\subsubsection{Alosztály}
+
+\begin{outline}
+	\1 Speciális eset, kevesebb egyede van, több tulajdonsága
+	\1 Azaz extra attribútumokat vezethetünk be hozzájuk
+	\1 Viszont az alosztály egyedei az őszosztály egyedei is egyben
+	\1 Nem engedjük a többszörös öröklődést: alosztályok rendszere egy fa
+	\1 Jelölés: ősosztályra mutató háromszög, beleírva "az egy"
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.25\linewidth]{EK-alosztály}
+\end{figure}
+
+\subsubsection{Kulcs}
+
+\begin{outline}
+	\1 Kulcs: attribútumok halmaza, amelyekre nincs két olyan egyed, hogy a kulcs minden attribútuma azonos legyen
+	\1 Minden egyedhalmaznak van kulcsa
+	\1 Jelölés: attribútum nevének aláhúzásával
+	\1 Alosztálynak nincs külön kulcsa: ősosztály kulcsa vonatkozik rá
+\end{outline}
+
+\subsubsection{Gyenge egyedhalmaz}
+
+\begin{outline}
+	\1 Egyedeit csak külső segítséggel lehet egyértelműen azonosítani: egy/több sok-egy kapcsolatot kell követni és a kapott egyedek kulcsértékei kellenek
+	\1 Gyenge egyedhalmaz jelölése: dupla szélű téglalap
+	\1 Támogató sok-egy kapcsolat jelölése: dupla szélű rombusz
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.3\linewidth]{EK-gyenge-egyedhalmaz}
+\end{figure}
+
+\pagebreak
+
+\subsection{Tervezési technikák}
+
+\begin{outline}
+	\1 Redundancia elkerülése
+		\2 Helypazarlás
+		\2 Növeli az inkonzisztencia veszélyét
+	\1 Gyenge egyedhalmazok óvatos használata
+		\2 Általában jó, ha minden egyedhalmaznak van saját kulcsa
+		\2 Saját kulcs készítése nem mindig lehetséges: nincs, ami kiosztaná ezeket (decentralizált rendszerek)
+	\1 Attribútum használata egyedhalmaz helyett, ha lehetséges
+		\2 Egyedhalmaz kell, ha ezek közül egy teljesül:
+			\3 van legalább egy nem kulcs attribútum benne
+			\3 egy "sok-egy" kapcsolatnak a "sok" végén szerepel
+\end{outline}
+
+\subsection{E/K diagrammból relációséma}
+
+\begin{outline}
+	\1 Egyedhalmazból reláció, attribútumból attribútum
+	\1 Kapcsolatból reláció, aminek attribútumai:
+		\2 összekapcsolt egyedhalmazok kulcsai
+		\2 kapcsolat saját attribútumai
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.4\linewidth]{EK-relációvá}
+\end{figure}
+
+	\1 Relációk összevonása: egyedhalmaz relációja összevonaható az egyedhalmazzal sok-egy kapcsolatban álló reláció, ha az eredeti egyedhalmaz a "sok", a másik pedig az "egy" oldalon van
+		\2 Sok-sok kapcsolat összevonása helytelen, redundanciához vezet
+
+\pagebreak
+
+	\1 Gyenge egyedhalmazból reláció:
+		\2 Relációnak a teljes kulcsot tartalmaznia kell.
+		\2 Támogató kapcsolatokat nem írjuk át (redundanciához vezetne)
+	\1 Alosztályok átalakítása
+		\2 NULL értékek használata
+			\3 Alosztály nem hoz be újabb relációt, csak újabb oszlopo(ka)t
+			\3 Helytakarékos, kivéve, ha sok a NULL érték
+			\3 Összekapcsolásokat is megspórolja
+		\2 Objektumorientált megközelítés
+			\3 Ősosztálynak és alosztálynak külön reláció
+			\3 Ősosztály minden oszlopa létezik az alosztályban is
+			\3 Egy egyed csak az egyik relációban van benne
+			\3 Hasznos, ha az ősosztály nem-kulcs az alosztály oszlopait érintő lekérdezésekhez
+		\2 E/K style
+			\3 Ősosztálynak és alosztálynak külön reláció
+			\3 Ősosztálynak csak a kulcs oszlopai léteznek az alosztály relációban
+			\3 Egy egyed mindkét relációban benne van
+			\3 Összekapcsolás szükséges, hogy minden adat egyszerre meglegyen
+			\3 Hasznos, ha az alosztályt csak ritkán használjuk
+\end{outline}
+
+\pagebreak
+
+\section{Objektum-relációs adatbázisok}
+
+\subsection{Bevezetés}
+
+\begin{outline}
+	\1 Relációs és az objektumorientált modell egyesítése
+		\2 OO modell komplexebb adattípusokat is támogat
+		\2 Relációs modell magas szintű lekérdezéseket támogat
+		\2 Objektum-relációs adatmodell ezt a kettőt akarja megtartani
+	\1 Adatbázis-kezelő rendszerek (DBMS) fejlődése
+		\2 OO rendszerek sokáig nem voltak elég hatékonyak
+		\2 Relációs DBMS OO-val való kiterjesztése így jó megoldás volt
+	\1 Főbb különbségek:
+		\2 Attribútum típusa nem csak atomi típus lehet
+		\2 Metódusok
+		\2 Sorok egyéni azonosítót kapnak, lehet rájuk hivatkozást készíteni
+\end{outline}
+
+\subsection{Hivatkozások}
+
+\begin{outline}
+	\1 Cél: redundancia, módosítási anomáliák kiküszöbölése
+		\2 Áttekinthetőbb alternatíva egy kapcsolási táblára
+	\1 Hivatkozás típus rekurzívan van definiálva
+	\1 A attribútum R sémájú sorra történő...
+		\2 hivatkozás jelölés: A(*R)
+		\2 hivatkozás halmaz (több sorra hivatkozás) jelölés: A(\{*R\})
+	\1 Ha T egy UDT, akkor REF T egy hivatkozás (ami egy típus)
+	\1 OID (objektum azonosító): beépített azonosító, alapból rejtett
+	\1 Oracle: nincs különbség hivatkozás követés és normál mező elérés között
+		\2 De ha \texttt{ff.sör} egy hivatkozás, akkor \texttt{SELECT DEEREF(ff.sör)} kell
+	\1 SQL-99: ha \texttt{ff} egy reláció alias, akkor \texttt{ff.sör()->név}
+	\1 Beszúrás: \texttt{SELECT típus(REF(<alias>), ... FROM ....} segítségével
+\end{outline}
+
+\subsection{Felhasználó által definiált adattípus: User Defined Type, UDT}
+
+\begin{outline}
+	\1 Hasonló OOP-hez: adatszerkezet és annak metódusai
+	\1 Oracle: \texttt{CREATE TYPE <típusnév> AS OBJECT (<név-típus pár lista>);}
+		\2 SQL szabvány: AS után nincsen OBJECT
+	\1 1. felhasználási mód: sortípus: reláció ilyen adatokat tárol
+		\2 Egy oszlop van a táblában, azon belül több mező
+		\2 \texttt{CREATE TABLE <név> OF <UDT>;}
+		\2 Lekérdezés: \texttt{SELECT <alias.xy> FROM <reláció> <alias>}
+			\3 Oracle esetén az alias mindig kötelező
+			\3 SQL-99 esetén \texttt{xy} helyett \texttt{xy()} (egy generátor) kell
+		\2 Beszúrás
+			\3 Oracle: sima \texttt{INSERT}, konstruktor hívással
+			\3 SQL-99: mutátorok (\texttt{R.A(42)}) kellenek
+				\4 Először létre kell hozni egy változót: \texttt{SET v = MyType();}
+				\4 Utána mutálni kell: \texttt{v.x(42); v.y("valami");}
+				\4 Végül be kell szúrni: \texttt{INSERT INTO MyTable VALUES(v);}
+	\1 2. felhasználási mód: egy reláció attribútumának a típusa
+\end{outline}
+
+\pagebreak
+
+\subsection{Metódusok UDT-ken belül}
+
+\begin{outline}
+	\1 Oracle:
+		\2 CREATE TYPE-ban kell deklarálni, mint egy attribútumot:\\
+		\texttt{MEMBER FUNCTION <név>(<paraméterek>) RETURN <típus>, <pragma>}
+		\2 \texttt{PRAGMA RESTRICT\_REFERENCES(<metódus>, WNDS)}
+			\3 WNDS jelentése: nem módosíthat, csak read-only
+			\3 RNDS jelentése: ki sem olvassa az adatokat
+		\2 Definíció: \texttt{CREATE TYPE BODY <típus> AS MEMBER FUNCTION <metódus>(...) RETURN <típus> IS BEGIN ... END; END;}
+			\3 Paramétereknél itt már nem kell \texttt{IN/OUT}
+		\2 Saját objektum: SELF
+\end{outline}
+
+\subsubsection{Rendező metódusok}
+
+\begin{outline}
+	\1 Ezek segítségével működik az \texttt{ORDER BY, WHERE} lekérdezésben
+	\1 SQL-99: EQUAL, LESSTHAN (logikai visszatérési érték)
+	\1 Oracle: bármelyik lehet rendező metódus, nincs kötelező neve
+		\2 ORDER prefix kell MEMBER FUNCTION elé deklarációnál
+		\2 Kötelező pragma-k: WNDS, RNDS, WNPF, RNPS
+		\2 Visszatérési érték: szám (<0, =0, >0)
+\end{outline}
+
+\pagebreak
+
+\subsection{Beágyazott táblák}
+
+\begin{outline}
+	\1 Lényeg: oszlop típusa egy táblázat
+	\1 Séma típusú attribútum jelölés: AttrNév(AttrTag1, AttrTag2)
+		\2 Emlékeztető: ez nem egy tuple/struct, hanem egy táblázat
+	\1 Séma típus rekurzívan van definiálva (kiindulás: atomi típus)
+	\1 Példa: Oktatók(név, TAJ, címek(város, utca), tárgyak(tárgynév, kód))
+	\1 Csak Oracle szintaxist nézünk
+	\1 Tábla típus létrehozása: \texttt{CREATE TYPE S AS TABLE OF T}
+	\1 Beágyazott relációk tárolása Oracle-ben:
+		\2 "Fő" tábla létrehozásakor megadni az oszlop-tábla hol legyen tárolva
+		\2 \begin{verbatim}CREATE TABLE Gyártók (..., sörök SörTáblaTípus)
+		NESTED TABLE sörök STORE AS SörTábla;\end{verbatim}
+	\1 Beszúrás: tábla konstruktora, utána sorok felsorolása
+	\1 Beágyazott tábla lekérdezése:
+		\2 Minta sima érték lenne, csak egy listát kapunk vissza, mint "skalárt"
+		\2 Több beágyazott tábla esetén descartes szorzat a beágyazott táblákra
+	\1 Beágyazott táblán belüli lekérdezés
+		\2 Hagyományos táblává alakítás: \texttt{TABLE(SELECT .. FROM ..) <alias>}
+	\1 Beágyazott táblává alakítása (pl. beszúráshoz):\\
+	\texttt{CAST(MULTISET(SELECT ...) AS <type>)}
+\end{outline}
+
+\pagebreak
+
+\section{XML és XML/DTD sémák}
+
+\subsection{Félig strukturált modellek (semi-structured data)}
+
+\begin{outline}
+	\1 Félig strukturált modellek: XML, JSON, ...
+	\1 Félig strukturált
+		\2 Motiváció: adatok rugalmas megjelenítése
+		\2 Motiváció: dokumentumok átadása rendszerek (/adatbázisok) között
+		\2 Információt ad arról, hogy mi a séma (magán az adaton felül)
+	\1 Gráfként felfogható
+		\2 Csúcsok: objektumok
+		\2 Élek: kapcsolatok, címke a kapcsolat neve
+		\2 Levél: atomi értékek
+\end{outline}
+
+\subsection{XML (Extensible Markup Language) bevezetés}
+
+\begin{outline}
+	\1 Kezdő deklarációs sor: \texttt{<?xml version="1.0" encoding="utf-8" ?>}
+	\1 Tagek (jelölők): \texttt{<tag> ... </tag>}
+		\2 Tetszőlegesen egymásba ágyazhatók
+		\2 Üres tag: \texttt{<tag/>}
+		\2 Érzékenyek a kis- és nagybetű különbségekre
+	\1 Jól formált XML:
+		\2 Önálló tagek bevezetése megengedett
+		\2 Nem hiányzik a deklarációs sor
+		\2 Minden nyitó tagnak van záró párja + jó sorrend, "helyes zárójelezés"
+	\1 Valid XML: egy előre adott sémának megfelel, pl. DTD séma, XML séma
+\end{outline}
+
+\pagebreak
+
+\subsection{XML felhasználása}
+
+\begin{outline}
+	\1 Információintegrációs probléma:
+		\2 adatbázis modellek (relációs, NoSQL, stb) eltérnek
+		\2 sémák eltérnek
+		\2 más mértékegység, stb.
+	\1 Régi, örökölt adatbázisokra támaszkodnak régi alkalmazások, ezeket meg akarjuk tartani
+		\2 Megoldás: interfészt vezetünk be régi adatbázisok fölé
+		\2 Új felhasználó az interfészen keresztül lép kapcsolatba az adattal
+		\2 Az interfész közös több örökölt adatbázison
+	\1 Integrációra két megközelítés: (mi legyen az interfész)
+		\2 Adattárházba naponta/hetente szinkronizáció
+			\3 Egy csomagoló adatbázisból adattárházba viszi az adatot
+			\3 Egy irányú a megoldás: adattárházból nem lehet módosítani
+				\4 Ez biztos?
+		\2 Nézetek létrehozása, mintha integrált rendszer részei lennének
+			\3 Mediátor csomagolókon keresztül beszél az adatbázisokkal
+			\3 Két irányú a kapcsolat: lekérdezés és módosítás is lehet
+\end{outline}
+
+\pagebreak
+
+\subsection{DTD séma}
+
+\begin{outline}
+	\1 Speciális formátumot használ (nem XML)
+	\1 Felhasználás
+		\2 <!DOCTYPE ...> a deklarációs sor és a dokumentum közé illeszthető
+		\2 külön fájl: <!DOCTYPE kocsmák SYSTEM "bar.dtd">
+	\1 Elemek: \texttt{<!ELEMENT <név> (alelemek...)}
+		\2 Egy elemben lehet adat (levél, \texttt{\#PCDATA}) vagy elemek (vagy üres)
+		\2 Üres elem: <!ELEMENT valami EMPTY> (tag: <valami <attr...>/>)
+		\2 Alelemek megadása: típus és utána opcionálisan multiplicitás (*,+,?)
+		\2 Alelemeknél van VAGY (|): \texttt{<!ELEMENT név ((x,y) | (a,b))>}
+	\1 Attribútumok: \texttt{<!ATTLLIST Elem A1 Type1 Mod1 A2 Type2 Mod2...>}
+		\2 "Mod": \#IMPLIED (opcionális), \#REQUIRED (kötelező)
+			\3 \#DEFAULT (hogyan kell használni? nem hangzott el)
+			\3 \#FIXED (mindig egy adott értéket kell megadni... valahogy)
+		\2 Adattípusok: CDATA, ID, IDREF, IDREFS
+			\3 CDATA: szöveg
+			\3 ID, IDREF: egymásra mutathatnak az adatok, emiatt gráfot alkothatnak (nem pedig fát)
+			\3 ID: azonos típusú elemnek nem lehet ugyan ilyen értéke (unique)
+			\3 IDREF: nem tudjuk megmondani, hogy milyen típusú elemre mutasson
+			\3 IDREFS: egyszerre többre hivatkozás
+	\1 \begin{verbatim}
+	<!DOCTYPE kocsmák [
+	  <!ELEMENT kocsmák (kocsma*, sör*)>
+	  <!ELEMENT kocsma (felszolgál+)>
+	    <!ATTLIST kocsma név ID #REQUIRED>
+	  <!ELEMENT felszolgál (#PCDATA)>
+	    <!ATTLIST felszolgál melyikSör IDREF #REQUIRED>
+	  <!ELEMENT sör EMPTY>
+	    <!ATTLIST sör név ID #REQUIRED>
+	    <!ATTLIST sör kapható IDREFS #IMPLIED>
+	]>
+	\end{verbatim}
+\end{outline}
+
+\pagebreak
+
+\subsection{XML séma}
+
+\begin{outline}
+	\1 XML formátum, így az első sor: \texttt{<?xml version=... ?>}
+	\1 Root tag: \texttt{<xs:schema xmlns:xs="URL"> ... </xs:schema>}
+	\1 Felhasználás: <valami xmlns:xsi="schema-URL"\\
+	xsi:noNamespaceSchemaLocation="valami.xsd"> ... </valami>
+\end{outline}
+
+\subsubsection{Egyszerű element (xs:element)}
+
+\begin{outline}
+	\1 Kötelező attribútum: name (tag neve)
+	\1 Kötelező attribútum: type (érték típusa, pl. xs:string)
+	\1 Nincs alelem
+\end{outline}
+
+\subsubsection{Összetett típusok (nem element, csak típus)}
+
+\begin{outline}
+	\1 Nem kötelező nevesíteni, lehet egyből egy xs:element aleleme (pl. ha csak egyszer használjuk)
+	\1 Összetett (alelemet tartalmazó) típusok: xs:complexType
+		\2 Kötelező attribútum: name (tag neve)
+		\2 Típus: alelemek írják le
+	\1 xs:sequence: xs:element sorozata
+		\2 minOccurs és maxOccurs attribútumok minden xs:element-en
+		\2 occurs értékek: szám (0,1,stb.) vagy unbounded
+	\1 xs:attribute: name, type, use="required/optional" (alapból optional)
+\end{outline}
+
+\subsubsection{Megszorítás típusok (nem element, csak típus)}
+
+\begin{outline}
+	\1 Gyökér: xs:simpleType name=...
+	\1 Alelem: \texttt{<xs:restriction base=típus> ... </xs:restriction>}
+		\2 Típus: milyen típusú elemek lehetnek, mit szorítunk meg
+		\2 \texttt{\{min/max\}\{Inclusive/Exclusive\}}: alsó/felső korlát megadása
+	\1 Lehetséges elemek felsorolása: 1-1 \texttt{xs:enumeration value="..."} alelem
+\end{outline}
+
+\pagebreak
+
+\subsubsection{Kulcsok}
+
+\begin{outline}
+	\1 xs:element-hez tartozhat xs:key alelem: \texttt{<xs:key name="..."> ...}
+		\2 <xs:selector xpath="kocsma" />
+		\2 <xs:field xpath="@nev" /> (@ jelentése: attribútum)
+		\2 Jelentése: szelektor által megadott elemek adott field-jének mind unique-nak kell lennie
+	\1 xs:element-hez tartozhat: \texttt{<xs:keyref name="..." refer="kulcs">}:
+		\2 xs:key-hez hasonlóan selector és field beállítás kell
+		\2 Jelentése: bizonyos értékeknek egy létező kulcsot kell leírniuk
+\end{outline}
+
+\begin{verbatim}
+<?xml version = "1.0" encoding = "utf-8" ?>
+<xs:schema xmlns:xs = "http://www.w3.org/2001/XMLSchema">
+    <xs:complexType name = "sörTípus">
+        <xs:attribute name = "név" type = "xs:string" use = "required" />
+    </xs:complexType>
+    <xs:complexType name = "kocsmaTípus">
+        <xs:sequence>
+            <xs:element name = "sör" type = "sörTípus"
+                minOccurs = "1" maxOccurs = "unbounded" />
+        </xs:sequence>
+        <xs:attribute name = "név" type = "xs:string" use = "required" />
+    </xs:complexType>
+    <xs:complexType name = "kocsmákTípus" >
+        <xs:sequence>
+            <xs:element name = "kocsma" type = "kocsmaTípus"
+                minOccurs = "0" maxOccurs = "unbounded" />
+        </xs:sequence>
+    </xs:complexType>
+    <xs:element name = "kocsmák" type = "kocsmákTípus" />
+</xs:schema>
+\end{verbatim}
+
+\pagebreak
+
+\section{XML lekérdezőnyelvek}
+
+\begin{outline}
+	\1 XPath/XQuery adatmodell
+		\2 Tételek listájával (item sequence) dolgozunk: ez a bemenet, kimenet
+		\2 Tétel lehet: egyszerű (levél, skalár érték) vagy csomópont
+	\1 Csomópontok:
+		\2 dokumentum csomópont: teljes dokumentum (pl. doc(http://...))
+		\2 elem csomópont: xml tag és az alelemei
+		\2 attribútum
+\end{outline}
+
+\subsection{XPath}
+
+\begin{outline}
+	\1 Emlékeztető: eredmény mindig egy lista
+	\1 Tag-ek követése: /kocsmák/kocsma/ár (alemeket járunk be sorban)
+	\1 Attribútum hivatkozása: @ prefix
+	\1 Nem csak a gyökérből lehet indulni:
+		\2 //X/... a dokumentumban bárhol (gyökérben vagy lejjebb) lévő X tag-től indul
+		\2 Eredmény sorrendben lesz: feljebb (pl. gyökérből) induló esetek lesznek először
+		\2 Nem csak gyökér szinten lehet alkalmazni, hanem lejjebb is
+	\1 Tetszőleges tag: * (pl. /*/*/ár)
+	\1 Feltételek: tag után [...]
+		\2 Atomi értékű törzsre szűrés: [text()]
+		\2 Szám összehasonlítás: [. < 3.14] \;\; (. az aktuális elem)
+		\2 Attribútum megszorítás: [@valami = "xyz"]
+\end{outline}
+
+\pagebreak
+
+\begin{outline}
+	\1 Tengelyek (axes): következő lépésnél feldolgozandóak listája
+		\2 Alapértelmezett: \texttt{child::} (pl. /child::kocsmák)
+		\2 attribute:: (@ hosszú formája)
+		\2 parent:: (pl. //könyv/cím[. = 'Valami']/parent::könyv)
+		\2 descendant-or-self:: (hasonló a //-hez)
+		\2 ancestor::, ancestor-or-self::
+		\2 self:: (. hosszú formája)
+\end{outline}
+
+\section{XQuery}
+
+\begin{outline}
+	\1 Nem vettük, nem maradt rá idő
+\end{outline}
+
+\pagebreak
+
+%EA - GYAK ELVÁLASZTÓ
+
+\section{Relációs algebra gyakorlati jegyzet}
+
+\begin{outline}
+	\1 $\sigma_{x=NULL}$ az nem része az alap algrebrának, csak a kiterjesztett algebrának
+	\1 Relációs algebra mindig átírható SQL-be, de visszafelé nem
+		\2 pl. alkérdések nincsenek relációs algebrában
+	\1 Tábla indexelve: átnevezés, csak így könnyebb (hivatalosan: $\rho_{Sz_1}(Sz)$)
+	\1 Min két gyümölcsöt szeret: $Sz_1 \times Sz_2$, 1 sorban 2 különböző gyümölcs
+	\1 Gyakorlaton $\rightouterjoin$ helyett $\bowtie_R$ jelet használjuk (teljes: $_L \bowtie_R$)
+	\1 Komplementer halmaz képzés: $( \Pi_{name}(SZ) \times \Pi_{fruit} (SZ) ) \setminus (SZ)$
+	\1 Tábla nevét $\bowtie$-nál mindig ki kell írni, kivéve, ha NATURAL JOIN van
+\end{outline}
+
+\subsection{Kiterjesztett algebra}
+
+\begin{outline}
+	\1 Multihalmazzal dolgozunk
+	\1 Létezik NULL érték
+	\1 Csoportképzés (group by féleség): $\gamma$ (gamma)
+		\2 GROUP BY X, COUNT(Y) AS db: $\gamma_{X,COUNT(Y) \to db} (R)$
+		\2 Aggregációs függvények: MIN, MAX, SUM, AVG, COUNT
+		\2 Ezután csak az alsó indexben lévőket lehet használni
+		\2 Lehet 0/1/több oszlop alapján group-olni, lehet 0/1/többet aggregálni
+		\2 Relációs algebrában nincs külön WHERE ÉS HAVING (csak $\sigma$)
+		\2 Relációs algebrában is van COUNT(*)
+		\2 COUNT(DISTINCT X) = COUNT($\delta$ X)
+	\1 Sorba rendezés: $\tau$ (tau), ORDER BY X: $\tau_{X} (R)$
+\end{outline}
+
+\pagebreak
+
+\section{SQL függvények, műveletek}
+
+\begin{outline}
+	\1 Dátum, idő
+		\2 TO\_DATE('2000-01-01', 'YYYY-MM-DD') -> dátum
+		\2 TO\_CHAR(DATE, 'YYYY-MM-DD') -> szöveg
+		\2 SYSDATE -> aktuális dátum \;\;\; (NEM FÜGGVÉNY)
+		\2 Dátumok kivonása a napok számát adja meg
+	\1 Szöveg (string) kezelés
+		\2 Oracle 1-től indexel
+		\2 SUBSTR('valami', 2, 1) -> a
+		\2 SUBSTR('valami', -2, 1) -> m
+		\2 SUBSTR('valami', 2) -> 'alami'
+		\2 LENGTH('alma') -> 4
+		\2 INSTR('valami', 'a', 1, 2) -> 2. 'a' pozíciója az 1-es index után
+		\2 RPAD('a', 4, '\#') -> 'a\#\#\#', LPAD, üres szöveget nem lehet
+		\2 UPPER('alma') -> 'ALMA', LOWER
+		\2 mezo (NOT) LIKE '\_I\%' -> 2. betű I, hossza >= 2
+		\2 Konkatenáció: \texttt{'a' || 'b'}
+	\1 Matematika
+		\2 ROUND(0.123, 2) -> 0.12
+		\2 SQRT(x), FLOOR(x), CEIL(x)
+		\2 MOD(x, 2)
+		\2 LEAST(a, b), GREATEST(a, b)
+	\1 NVL(NULL, 'Ismeretlen', ...) -> első nem-NULL érték
+	\1 TO\_NUMBER('42') és TO\_CHAR(42)
+\end{outline}
+
+\pagebreak
+
+\section{PL/SQL (PL SQL, PLSQL) programozás}
+
+\subsection{Függvény, procedura létrehozás}
+
+\begin{outline}
+	\1 Sql Developer buta és nem ismeri fel, hogy hol ér véget a fv
+		\2 Tehát ki kell jelölni a fv-t és csak az fv-t és úgy futtatni
+	\1 \begin{verbatim}
+CREATE OR REPLACE PROCEDURE <név> (params...) IS
+    <változó> <típus> [:= kezdőérték];
+  BEGIN
+    ... --Minden sor végén ;
+  END [név];
+	\end{verbatim}
+		\2 Hívása: CALL <név>(params...);
+	\1 \begin{verbatim}CREATE OR REPLACE FUNCTION <név> (params...) RETURN <típus> IS ...\end{verbatim}
+		\2 Hívás: SELECT <név>(params1), <név>(params2) FROM dual;
+	\1 Paraméterek: pl. [IN] [OUT] nev VARCHAR2 (nincs méret!)
+		\2 IN (bemeneti): alapból minden ez, nem lehet módosítani
+		\2 IN OUT: konstans nem adható át ennek
+\end{outline}
+
+\subsection{Nyelvi konstrukciók}
+
+\begin{outline}
+	\1 For ciklus: FOR i IN 1..n LOOP ... END LOOP;
+		\2 Másik irányban: ... IN REVERSE ...
+	\1 While ciklus: WHILE n > 0 LOOP ... END LOOP;
+	\1 IF <felt> THEN ... [ELSIF <felt> THEN ...] [ELSE ...] END IF;
+	\1 Loop-ból kilépés: \texttt{EXIT WHEN ...}
+	\1 Early "return": \texttt{IF ... THEN CONTINUE; END IF;}
+\end{outline}
+
+\pagebreak
+
+\subsection{Egyéb tudnivalók, trükkök}
+
+\begin{outline}
+	\1 \begin{verbatim}dbms_output.put_line('Hello' || 'nev'); --debug msg\end{verbatim}
+		\2 Be kell kapcsolni: \texttt{SET SERVEROUTPUT ON} (egy ideig hat)
+	\1 Név nélküli blokk, függvény hívás egyszerűen:\\
+	\texttt{DECLARE n := 42; BEGIN test(n); END;}
+	\1 Szöveg típus: \texttt{VARCHAR2}, ami üres esetén \texttt{NULL}
+		\2 Általában nem baj, ha a függvényünk ilyen bemenetre nem működik
+		\2 Ha üreshez akarunk konkatenálni, lehet érdemes inkább \texttt{VARCHAR1}
+	\1 Tábla másolás, extra oszlop létrehozásávál:\\
+	\texttt{CREATE TABLE ... AS SELECT dolgozo.*, 1 sorszam FROM dolgozo;}
+\end{outline}
+
+\subsection{Adat bekérés, prompt, \texttt{ACCEPT}}
+
+\begin{outline}
+	\1 Egy makró-t töltünk fel (ami egy C-s \verb|#define| féleség)
+	\1 Hasznos ZH-n név nélküli blokkok tesztelésére
+	\1 \texttt{ACCEPT <név> <típus> PROMPT 'Popup prompt szöveg';}
+	\1 Makró használat: \texttt{\&<név>}
+		\2 Ha makró szöveg volt, attól még idézőjelek nincsenek ebben benne
+		\2 Ilyenkor használat: \texttt{'\&<név>'}
+	\1 \texttt{ACCEPT} sor nélkül is jó, de ekkor minden futtatáskor bekéri az értékét
+\end{outline}
+
+\pagebreak
+
+\subsection{Kurzorok (\texttt{CURSOR})}
+
+\begin{verbatim}
+	CREATE OR REPLACE PROCEDURE teszt IS
+	  CURSOR curs1 IS SELECT * FROM SZ;
+	  rec curs1%rowtype; --1. lehetőséghez kell
+	BEGIN
+	  --1. lehetőség: bonyolult, több kurzoros feladatra is jó
+	  OPEN curs1;
+	  LOOP 
+	    FETCH curs1 INTO rec;
+	    EXIT WHEN curs1%NOTFOUND;
+	    -- valami(rec.adattag);
+	  END LOOP;
+	  CLOSE curs1;
+	  
+	  --2. lehetőség, nem kell a fenti 'rec' deklaráció
+	  FOR rec IN curs1 LOOP
+	    -- valami(rec.adattag);
+	  END LOOP;
+	END;\end{verbatim}
+
+\subsubsection{Kurzorok módosításra}
+
+\begin{outline}
+	\1 Deklarálás: \texttt{CURSOR curs1 IS ... FOR UPDATE;}
+		\2 UPDATE: akár delete-elni is lehet, nincs köze az UPDATE kulcsszóhoz
+	\1 Lehet több olvasó, de egyszerre csak 1 író (és írás kizárja az olvasást)
+		\2 \texttt{FOR UPDATE} nélküli eljárásban hívhatunk meg módosító eljárást
+	\1 Cache-elt ResultSet-en iterálunk: iterálás közbeni változtatás nem látszik
+	\1 Változtatás SQL-lel: \texttt{UPDATE ... SET ... WHERE CURRENT OF curs1;}
+		\2 \texttt{rec} és tábla módosítása nem módosítja egymást
+		\2 Manuálisan frissíthetjük a \texttt{rec}-et, majd azzal a táblát
+	\1 Kapcsolt táblán iterálás, egyiken módosítás:
+		\2 \texttt{FOR UPDATE} helyett \texttt{FOR UPDATE OF <oszlopnév...>}
+		\2 Ez teljes zárat ad a táblára, nem csak az oszlopra (törölni is lehet)
+	\1 Módosító \texttt{FUNCTION}-t \texttt{SELECT} helyett név nélküli blokkban futtatunk
+\end{outline}
+
+\pagebreak
+
+\section{Példák}
+
+\subsection{Tábla létrehozás}
+
+\begin{verbatim}
+DROP TABLE teszt_1;
+CREATE TABLE teszt_1 (
+  lebego REAL NOT NULL,
+  egesz INT DEFAULT 0,
+  nev VARCHAR2(100) UNIQUE,
+  CONSTRAINT pk_teszt_1 PRIMARY KEY (egesz, nev)
+);
+
+DROP TABLE teszt_2;
+CREATE TABLE teszt_2 (
+  datum DATE PRIMARY KEY
+);
+
+DROP TABLE teszt_3;
+CREATE TABLE teszt_3 (
+  egesz INT,
+  nev VARCHAR2(100),
+  datum DATE REFERENCES teszt_2 (datum),
+  CONSTRAINT fk_teszt_1 FOREIGN KEY (egesz, nev)
+                        REFERENCES teszt_1 (egesz, nev)
+);
+\end{verbatim}
+
+\pagebreak
+
+\subsection{PL/SQL függvény}
+
+\begin{verbatim}
+CREATE OR REPLACE FUNCTION faktor(n INTEGER) RETURN INTEGER IS
+  val INTEGER := 1;
+BEGIN
+  FOR i IN 2..n LOOP
+    val := val * i;
+  END LOOP;
+  RETURN val;
+END;
+SELECT faktor(0), faktor(5) FROM dual;
+\end{verbatim}
+
+\subsection{PL/SQL eljárás}
+
+\begin{verbatim}
+CREATE OR REPLACE PROCEDURE paratlan IS
+  CURSOR curs1 IS SELECT * FROM dolgozo ORDER BY dnev;
+  sorszam INT := 0;
+BEGIN
+  FOR rec IN curs1 LOOP
+    sorszam := sorszam + 1;
+    IF MOD(sorszam, 2) = 1 THEN
+      dbms_output.put_line(TO_CHAR(sorszam) || '.: Név: '
+          || rec.dnev || ', fizetés: ' || TO_CHAR(rec.fizetes));
+    END IF;
+  END LOOP;
+END;
+SET SERVEROUTPUT ON;
+CALL paratlan();
+\end{verbatim}
+
+\end{document}
diff --git a/adatb1/joins.png b/adatb1/joins.png
new file mode 100644
index 0000000..95472a4
Binary files /dev/null and b/adatb1/joins.png differ
diff --git a/adatb1/relalg-optimize-full.png b/adatb1/relalg-optimize-full.png
new file mode 100644
index 0000000..96ea9b5
Binary files /dev/null and b/adatb1/relalg-optimize-full.png differ
diff --git a/adatb1/relalg-optimize-short.png b/adatb1/relalg-optimize-short.png
new file mode 100644
index 0000000..94abfa2
Binary files /dev/null and b/adatb1/relalg-optimize-short.png differ
diff --git a/algo2/README.md b/algo2/README.md
new file mode 100644
index 0000000..4df5f69
--- /dev/null
+++ b/algo2/README.md
@@ -0,0 +1,11 @@
+**Képzés:** ELTE IK Proginf BSc, Szoftvertervező (B) szakirány (kezdés éve: 2020)  
+**Tárgy neve:** Algoritmusok és adatszerkezetek II  
+**Tárgy kódja:** IP-18AA2E/G
+
+A jegyzet témakörönként külön-külön fájlra van bontva.
+
+Linkek:
+ - [Fák jegyzet link](fák/algo2-fák.pdf)
+ - [Gráf jegyzet link](fák/algo2-gráf.pdf)
+ - [Mintaillesztés jegyzet link](fák/algo2-mintaillesztés.pdf)
+ - [Tömörítés jegyzet link](fák/algo2-tömörítés.pdf)
diff --git "a/algo2/f\303\241k/algo2-f\303\241k.pdf" "b/algo2/f\303\241k/algo2-f\303\241k.pdf"
new file mode 100644
index 0000000..3ecef5e
Binary files /dev/null and "b/algo2/f\303\241k/algo2-f\303\241k.pdf" differ
diff --git "a/algo2/f\303\241k/algo2-f\303\241k.tex" "b/algo2/f\303\241k/algo2-f\303\241k.tex"
new file mode 100644
index 0000000..f3ec433
--- /dev/null
+++ "b/algo2/f\303\241k/algo2-f\303\241k.tex"
@@ -0,0 +1,332 @@
+% !TeX spellcheck = hu_HU
+\documentclass[12pt,a4paper]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{cmap}
+\usepackage[T1]{fontenc}
+\usepackage[magyar]{babel}
+\usepackage{amsmath}
+\usepackage{amsfonts}
+\usepackage{amssymb}
+\usepackage{graphicx}
+
+\usepackage{struktex}
+\usepackage{outlines}
+\usepackage{hyperref}
+
+\hyphenpenalty=10000
+
+\begin{document}
+
+\begin{center}
+	\huge
+	Algoritmusok és adatszerkezetek II\\
+	\vspace{1mm}
+	\LARGE
+	Fák témakör jegyzete\\
+	\vspace{5mm}
+	\large
+	Készült Ásványi Tibor előadásai és gyakorlatai alapján\\
+	\vspace{5mm}
+	Sárközi Gergő, 2021-22-1. félév\\
+	Nincsen lektorálva!
+\end{center}
+
+\tableofcontents
+
+\pagebreak
+
+\section{AVL fák}
+
+\begin{outline}
+	\1 (magasság szerint) kiegyensúlyozott bináris keresőfa
+		\2 egy fa kiegyensúlyozott, ha minden csúcsa kiegyensúlyozott
+		\2 $*p$ kiegyensúlyozott, ha $|p\to b|\le1$
+		\2 $p\to b = h(p\to right) - h(p\to left)$
+	\1 AVL fákat láncoltan reprezentálunk
+	\1 legyen $n=|t|$ (csúcsok száma) és $h=h(t)$
+	\1 $ \lfloor log n \rfloor \le h \le 1,45 \log n \implies h \in \Theta(log n) $
+		\2 Felső becslés, alsó határ: $n<2^{h+1} \implies \lfloor log n \rfloor \le h$
+		\2 Fibonacci fák: $h$ mélységű, legkisebb méretű KBF-ek (kiegyensúlyozott bináris fák) csúcsainak száma: \\
+		$f_0=1$, $f_1=2$, $f_h=1+f_{h-1}+f_{h-2}$ $(h\ge2)$ \\
+		Ebből megkapható a $h \le 1,45 \log n$ \\
+		$f_h = F_{h+3}-1$ (ahol F a rendes fibonacci sorozat)
+	\1 $h(t) \le n-1$
+\end{outline}
+
+\begin{table}[h!]
+\centering
+\begin{tabular}{|l|c|l|}
+	\hline
+	\multicolumn{1}{|c|}{Függvény} & \multicolumn{1}{|c|}{Komplexitás} & \multicolumn{1}{|c|}{Leírás} \\
+	\hline
+	search($t:Node^*; k:\mathbb{T}$) : $Node^*$ & $\Theta(\log n)$ & \\
+	\hline
+	min($t:Node^*$) : $Node^*$ & $\Theta(\log n)$ & ugyan így van max(t) \\
+	\hline
+	AVLinsert($\&t:Node^*; k:\mathbb{T}; \&d:\mathbb{B}$) & $\Theta(\log n)$ & d igaz, ha nőtt h(t) \\
+	\hline
+	AVLremMin($\&t,\&minp:Node^*; \&d:\mathbb{B}$) & $\Theta(\log n)$ & d igaz, ha csökkent h(t) \\
+	\hline
+	AVLdel($\&t:Node^*; k:\mathbb{T}; \&d:\mathbb{B}$) & $\Theta(\log n)$ & d igaz, ha csökkent h(t) \\
+	\hline
+\end{tabular}
+\end{table}
+
+\begin{table}[h!]
+	\centering
+	\begin{tabular}{|l|}
+		\hline
+		\multicolumn{1}{|c|}{Node} \\
+		\hline
+		+ $key : \mathbb{T}$ \\
+		+ $b : \{-1,0,1\}$ \\
+		+ $left, right : Node^*$ \\
+		\hline
+		+ $Node() \{left:=right:=\emptyset ; b:=0\}$ \\
+		+ $Node(x:\mathbb{T}) \{left:=right:=\emptyset ; b:=0 ; key := x\}$ \\
+		\hline
+	\end{tabular}
+\end{table}
+
+\pagebreak
+
+\subsection{Beszúrás}
+
+\subsubsection{Kiegyensúlyozás beszúrás miatt}
+
+\begin{outline}
+	\1 Minden esetben 1 vagy 2 lépés (BESZÚRÁS UTÁN CSAK!)
+	\1 Nem változtat az inorder bejáráson (logikus, hiszen keresőfa)
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=1\linewidth]{forgatas_PPp}
+	\includegraphics[width=1\linewidth]{forgatas_MMm}
+	\includegraphics[width=1\linewidth]{balance_PPp_MMm}
+\end{figure}
+
+\begin{figure}[p]
+	\centering
+	\includegraphics[width=1\linewidth]{forgatas_PPm}
+	\includegraphics[width=1\linewidth]{forgatas_MMp}
+	\includegraphics[width=1\linewidth]{balance_PPm_MMp}
+\end{figure}
+
+\pagebreak
+
+\subsubsection{Beszúrás algoritmus}
+
+\begin{outline}
+	\1 megkeressük a kulcs helyét
+		\2 ha a kulcs benne van, kész vagyunk
+		\2 ha a kulcs helyén lévő részfa üres: beszúrunk egy levélcsúcsot, így a részfa eggyel magasabb lett
+	\1 rálépünk a szülőre és az egyensúlyát módosítjuk (amelyikből ráléptünk, az a gyerek lett eggyel magasabb, szóval balance + vagy - 1)
+		\2 ha balance=0, akkor kész vagyunk
+		\2 ha |balance|=1, akkor ez a részfa magasabb lett eggyel, ismét rálépünk a szülőre, stb.
+		\2 ha |balance|=2, akkor ki kell egyensúlyozni ezt a részfát, miután visszanyeri az eredeti (beszúrás előtti) magasságát, tehát a kiegyensúlyozás után kész vagyunk
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.8\linewidth]{insert}
+\end{figure}
+
+\pagebreak
+
+\subsection{Törlés}
+
+\begin{outline}
+	\1 Törlésnél akár több (akár gyökérig tartó) forgatás (kiegyensúlyozás) kell.
+	Azért, mert a forgatások csökkentik a részfa magasságát, és a törlés is.
+	\1 Törlés fajtái:
+		\2 törlendő csúcs egyik részfája üres (levél vagy egy gyerekes csúcs):
+		a másik részfát tesszük a csúcs helyére (ami lehet null) és a szülő balance-ját módosítjuk
+		\2 kétgyerekes csúcs törlése: jobb részfa minimumjának kiemelése, fa kiegyensúlyozása,
+		kicseréljük a törlendő csúcsot a kiemelt csúccsal
+\end{outline}
+
+\subsubsection{Kiegyensúlyozás törlés miatt}
+
+\begin{outline}
+	\1 Akárhány lépés lehet: forgatások és a törlés is csökkentik a részfa magasságát
+	\2 Nem változtat az inorder bejáráson (hiszen keresőfa)
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=1\linewidth]{forgatas_PP0}
+	\includegraphics[width=1\linewidth]{forgatas_MM0}
+\end{figure}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=1\linewidth]{balance_PP0}
+	TODO balance MM metódus, stb.
+\end{figure}
+
+\subsubsection{remMin algoritmus}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.7\linewidth]{remMin}
+\end{figure}
+
+\pagebreak
+
+\subsubsection{delRoot algoritmus}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.9\linewidth]{del}
+\end{figure}
+
+\pagebreak
+
+\section{Általános fák}
+
+\begin{outline}
+	\1 Csúcsnak tetszőlegesen sok gyereke lehet
+	\1 csúcshoz nem tartoznak üres részfák: egy csúcsnak annyi gyereke van, amennyi, nincs üres gyerek
+		\2 ezért nem r-áris fákról beszélni
+	\1 rendezett fa: ha a gyerekek sorrendje lényeges
+	\1 gyökér, levél fogalma ugyan úgy megvan
+	\1 $Node$ osztály tagjai: $child1,sibling:Node*$
+		\2 létezhetne szülő pointer is
+		\2 levél: $p \to child1 = \emptyset$
+		\2 utolsó testvér: $p \to sibling = \emptyset$
+	\1 szöveges ábrázolás: $(G\; t_1\; t_2\; ...\; t_n)$ (ahol G a gyökér)
+\end{outline}
+
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.9\linewidth]{általános fa bejárás}
+\end{figure}
+
+\pagebreak
+
+\section{B+ fák}
+
+\subsection{Felépítés}
+
+\begin{outline}
+	\1 $d$ a B+ fa fokszáma, $4 \le d$ (szóval r-áris fa, r=4)
+	\1 levelek:
+		\2 azonos szinten (mélységben) vannak
+		\2 adatokat tárolnak: minden kulcshoz tartozik egy adatra mutató
+		\2 szóval a levelekben azonos számú (max $d-1$) kulcs és mutató van
+	\1 belső csúcsok:
+		\2 max $d$ mutató és pontosan eggyel kevesebb kulcs
+		\2 belső kulcsok: hasító kulcsok
+		\2 kulcsok viszonya egymáshoz:
+			\3 legyen $n$ a részfák száma, $k$ a részfa bármelyik kulcsa
+			\3 legyen $K_i$ a szülő $i$. kulcsa ($1 \le i < n$)
+			\3 legszélső bal részfa: $k < K_1$
+			\3 legszélső jobb részfa: $K_{n-1} \le k$
+			\3 közbülső, $i$. részfa: $K_{i-1} \le k < K_i$
+	\1 gyerekek száma: (mindig max $d$)
+		\2 gyökér: min 2, vagy pontosan 0
+		\2 minden nem gyökér belső csúcs: min $\lfloor d/2 \rfloor$
+	\1 B+ fa által reprezentált adathalmaz minden értéke megjelenik egy levél kulcsaként, balról jobbra szigorúan monoton növekvő sorrendben
+\end{outline}
+
+\subsection{Műveleti igény}
+
+\begin{outline}
+	\1 Keresés, beszúrás, törlés: $\Theta(\log n)$
+\end{outline}
+
+\pagebreak
+
+\subsection{Beszúrás}
+
+\begin{outline}
+	\1 Üres a fa: készítsünk gyökeret, tartalmazza az értéket
+	\1 Keressük meg a levelet. Ha a levélben már szerepel a csúcs, fail.
+	\1 Ha nincs már a fában a kulcs és nem üres a fa:
+		\2 Ha a csúcsban van szabad hely, láncoljuk be oda rendezetten
+		\2 Ha a csúcs tele van, vágjuk szét két csúccsá, felezve az elemeket\\
+		(elemek közé sorolva az újat is) (ha páratlan: balra menjen több)
+			\3 szúrjuk be a jobb oldali csúcs legkisebb értékét a szülőbe
+				\4 ha nincs szülő (gyökérben vagyunk), hozzuk létre
+				\4 ha nem levél, akkor töröljük a régi helyről
+			\3 beszúrás miatt rekurzívan ismételni, amíg szükséges
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.5\linewidth]{b+ beszúrás egyszerű}
+\end{figure}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.5\linewidth]{b+ beszúrás bonyolult}
+\end{figure}
+
+\pagebreak
+
+\subsection{Törlés}
+
+Meg kell keresni a törlendő kulcsot tartalmazó levelet.
+Ha nincs ilyen: fail.
+
+\subsubsection{Megtalált levélcsúcs $=$ gyökér}
+
+\begin{outline}
+	\1 Töröljük a kulcsot és a mutatót
+	\1 Ha a gyökér tartalmaz még mutatót: kész vagyunk
+	\1 Ha a gyökér üres lett: töröljük, üres fát kapunk
+\end{outline}
+
+\subsubsection{Megtalált levélcsúcs $\ne$ gyökér}
+
+\begin{outline}
+	\1 Töröljük a kulcsot és a mutatót
+	\1 Ha a levél tartalmaz még elég mutatót ($\lfloor d/2 \rfloor$): kész vagyunk
+	\1 Ha a levél már túl kevés mutatót tartalmaz:
+		\2 De van bal/jobb testvére, aki tud adni:
+			\3 Kapjon a testvérétől annyit, hogy egyenlően el legyenek osztva a kulcsok
+			\3 Szülőben a két levélhez tartozó kulcs (1db) átírása a jobb testvér min kulcsára
+		\2 És nincs bal/jobb testvére, aki tudna adni:
+			\3 Egyesítsük egy testvérével: jobból átpakolunk a balba, a jobb oldali levelet töröljük
+			\3 Meghívunk egy törlő eljárást a szülőre: a két testvért eddig elválasztó kulcsot kell törölni (és a törölt csúcsra a mutatót)
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.5\linewidth]{b+ törlés levél}
+\end{figure}
+
+\pagebreak
+
+\subsubsection{Belső (nem gyökér) csúcsból törlés}
+
+\begin{outline}
+	\1 Töröljük a egyesített csúcsok közötti hasító kulcsot és az egyesítés során törölt csúcsra a mutatót
+	\1 Ha a csúcs tartalmaz még elég mutatót ($\lfloor d/2 \rfloor$): kész vagyunk
+	\1 Ha a csúcs már túl kevés mutatót tartalmaz:
+		\2 De van bal/jobb testvére, aki tud adni:
+			\3 Osszuk a két testvér kulcsait és a szülőben az őket elválasztó kulcsot egyenlően
+			\3 A középső kulcs a szülőben lévőt cserélje ki
+			\3 A maradék menjen a két testvérbe (az kapjon többet, akinél eddig is több volt)
+		\2 És nincs bal/jobb testvére, aki tudna adni:
+			\3 Egyesítsük egy testvérével: először a bal oldali kulcsok, utána a két testvér szülőjében lévő elválasztó kulcs, végül a jobb oldali csúcs kulcsai jönnek
+			és a jobb oldali csúcsot töröljük
+			\3 Meghívunk egy törlő eljárást a szülőre: a két testvért eddig elválasztó kulcsot kell törölni (és a törölt csúcsra a mutatót)
+\end{outline}
+
+\subsubsection{Gyökérből (ami nem levél) törlés}
+
+\begin{outline}
+	\1 Töröljük a egyesített csúcsok közötti hasító kulcsot és az egyesítés során törölt csúcsra a mutatót
+	\1 Ha a gyökérnek van még min 2 gyereke: kész vagyunk
+	\1 Ha a gyökérnek 1 gyereke maradt: töröljük a gyökereket, a fa magassága csökken, az egyetlen gyerek lesz az új gyökér
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.8\linewidth]{b+ törlés belsőcsúcs}
+\end{figure}
+
+\end{document}
diff --git "a/algo2/f\303\241k/b+ besz\303\272r\303\241s bonyolult.png" "b/algo2/f\303\241k/b+ besz\303\272r\303\241s bonyolult.png"
new file mode 100644
index 0000000..5ed1164
Binary files /dev/null and "b/algo2/f\303\241k/b+ besz\303\272r\303\241s bonyolult.png" differ
diff --git "a/algo2/f\303\241k/b+ besz\303\272r\303\241s egyszer\305\261.png" "b/algo2/f\303\241k/b+ besz\303\272r\303\241s egyszer\305\261.png"
new file mode 100644
index 0000000..fbf8e19
Binary files /dev/null and "b/algo2/f\303\241k/b+ besz\303\272r\303\241s egyszer\305\261.png" differ
diff --git "a/algo2/f\303\241k/b+ t\303\266rl\303\251s bels\305\221cs\303\272cs.png" "b/algo2/f\303\241k/b+ t\303\266rl\303\251s bels\305\221cs\303\272cs.png"
new file mode 100644
index 0000000..4a691e4
Binary files /dev/null and "b/algo2/f\303\241k/b+ t\303\266rl\303\251s bels\305\221cs\303\272cs.png" differ
diff --git "a/algo2/f\303\241k/b+ t\303\266rl\303\251s lev\303\251l.png" "b/algo2/f\303\241k/b+ t\303\266rl\303\251s lev\303\251l.png"
new file mode 100644
index 0000000..e383e6d
Binary files /dev/null and "b/algo2/f\303\241k/b+ t\303\266rl\303\251s lev\303\251l.png" differ
diff --git "a/algo2/f\303\241k/balance_PP0.jpg" "b/algo2/f\303\241k/balance_PP0.jpg"
new file mode 100644
index 0000000..40a0e12
Binary files /dev/null and "b/algo2/f\303\241k/balance_PP0.jpg" differ
diff --git "a/algo2/f\303\241k/balance_PPm_MMp.jpg" "b/algo2/f\303\241k/balance_PPm_MMp.jpg"
new file mode 100644
index 0000000..2549b4d
Binary files /dev/null and "b/algo2/f\303\241k/balance_PPm_MMp.jpg" differ
diff --git "a/algo2/f\303\241k/balance_PPp_MMm.jpg" "b/algo2/f\303\241k/balance_PPp_MMm.jpg"
new file mode 100644
index 0000000..94fddee
Binary files /dev/null and "b/algo2/f\303\241k/balance_PPp_MMm.jpg" differ
diff --git "a/algo2/f\303\241k/del.jpg" "b/algo2/f\303\241k/del.jpg"
new file mode 100644
index 0000000..c8422b9
Binary files /dev/null and "b/algo2/f\303\241k/del.jpg" differ
diff --git "a/algo2/f\303\241k/forgatas_MM0.jpg" "b/algo2/f\303\241k/forgatas_MM0.jpg"
new file mode 100644
index 0000000..5a51cd5
Binary files /dev/null and "b/algo2/f\303\241k/forgatas_MM0.jpg" differ
diff --git "a/algo2/f\303\241k/forgatas_MMm.jpg" "b/algo2/f\303\241k/forgatas_MMm.jpg"
new file mode 100644
index 0000000..aa0713b
Binary files /dev/null and "b/algo2/f\303\241k/forgatas_MMm.jpg" differ
diff --git "a/algo2/f\303\241k/forgatas_MMp.jpg" "b/algo2/f\303\241k/forgatas_MMp.jpg"
new file mode 100644
index 0000000..ed436a3
Binary files /dev/null and "b/algo2/f\303\241k/forgatas_MMp.jpg" differ
diff --git "a/algo2/f\303\241k/forgatas_PP0.jpg" "b/algo2/f\303\241k/forgatas_PP0.jpg"
new file mode 100644
index 0000000..0a4b535
Binary files /dev/null and "b/algo2/f\303\241k/forgatas_PP0.jpg" differ
diff --git "a/algo2/f\303\241k/forgatas_PPm.jpg" "b/algo2/f\303\241k/forgatas_PPm.jpg"
new file mode 100644
index 0000000..82b8c02
Binary files /dev/null and "b/algo2/f\303\241k/forgatas_PPm.jpg" differ
diff --git "a/algo2/f\303\241k/forgatas_PPp.jpg" "b/algo2/f\303\241k/forgatas_PPp.jpg"
new file mode 100644
index 0000000..3a120c6
Binary files /dev/null and "b/algo2/f\303\241k/forgatas_PPp.jpg" differ
diff --git "a/algo2/f\303\241k/insert.jpg" "b/algo2/f\303\241k/insert.jpg"
new file mode 100644
index 0000000..c5c5a12
Binary files /dev/null and "b/algo2/f\303\241k/insert.jpg" differ
diff --git "a/algo2/f\303\241k/remMin.jpg" "b/algo2/f\303\241k/remMin.jpg"
new file mode 100644
index 0000000..7cddfb8
Binary files /dev/null and "b/algo2/f\303\241k/remMin.jpg" differ
diff --git "a/algo2/f\303\241k/\303\241ltal\303\241nos fa bej\303\241r\303\241s.jpg" "b/algo2/f\303\241k/\303\241ltal\303\241nos fa bej\303\241r\303\241s.jpg"
new file mode 100644
index 0000000..fd535b8
Binary files /dev/null and "b/algo2/f\303\241k/\303\241ltal\303\241nos fa bej\303\241r\303\241s.jpg" differ
diff --git "a/algo2/gr\303\241f/DAGshP-p\303\251lda.png" "b/algo2/gr\303\241f/DAGshP-p\303\251lda.png"
new file mode 100644
index 0000000..69c24ce
Binary files /dev/null and "b/algo2/gr\303\241f/DAGshP-p\303\251lda.png" differ
diff --git "a/algo2/gr\303\241f/DAGshP.png" "b/algo2/gr\303\241f/DAGshP.png"
new file mode 100644
index 0000000..4bc7857
Binary files /dev/null and "b/algo2/gr\303\241f/DAGshP.png" differ
diff --git "a/algo2/gr\303\241f/FloydWarshall.png" "b/algo2/gr\303\241f/FloydWarshall.png"
new file mode 100644
index 0000000..76a5ceb
Binary files /dev/null and "b/algo2/gr\303\241f/FloydWarshall.png" differ
diff --git "a/algo2/gr\303\241f/GenMST.png" "b/algo2/gr\303\241f/GenMST.png"
new file mode 100644
index 0000000..03e5e1f
Binary files /dev/null and "b/algo2/gr\303\241f/GenMST.png" differ
diff --git "a/algo2/gr\303\241f/QBF-p\303\251lda-j\303\263.png" "b/algo2/gr\303\241f/QBF-p\303\251lda-j\303\263.png"
new file mode 100644
index 0000000..33b74e0
Binary files /dev/null and "b/algo2/gr\303\241f/QBF-p\303\251lda-j\303\263.png" differ
diff --git "a/algo2/gr\303\241f/QBF-p\303\251lda-k\303\266r.png" "b/algo2/gr\303\241f/QBF-p\303\251lda-k\303\266r.png"
new file mode 100644
index 0000000..1869973
Binary files /dev/null and "b/algo2/gr\303\241f/QBF-p\303\251lda-k\303\266r.png" differ
diff --git "a/algo2/gr\303\241f/QBF.png" "b/algo2/gr\303\241f/QBF.png"
new file mode 100644
index 0000000..4f3fd40
Binary files /dev/null and "b/algo2/gr\303\241f/QBF.png" differ
diff --git "a/algo2/gr\303\241f/TransitiveClosure.png" "b/algo2/gr\303\241f/TransitiveClosure.png"
new file mode 100644
index 0000000..2fd1247
Binary files /dev/null and "b/algo2/gr\303\241f/TransitiveClosure.png" differ
diff --git "a/algo2/gr\303\241f/algo2-gr\303\241f.pdf" "b/algo2/gr\303\241f/algo2-gr\303\241f.pdf"
new file mode 100644
index 0000000..a1a4f14
Binary files /dev/null and "b/algo2/gr\303\241f/algo2-gr\303\241f.pdf" differ
diff --git "a/algo2/gr\303\241f/algo2-gr\303\241f.tex" "b/algo2/gr\303\241f/algo2-gr\303\241f.tex"
new file mode 100644
index 0000000..f8aaa71
--- /dev/null
+++ "b/algo2/gr\303\241f/algo2-gr\303\241f.tex"
@@ -0,0 +1,747 @@
+% !TeX spellcheck = hu_HU
+\documentclass[12pt,a4paper]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{cmap}
+\usepackage[T1]{fontenc}
+\usepackage[magyar]{babel}
+\usepackage{amsmath}
+\usepackage{amsfonts}
+\usepackage{amssymb}
+\usepackage{graphicx}
+
+\usepackage{struktex}
+\usepackage{outlines}
+\usepackage{hyperref}
+
+\hyphenpenalty=10000
+
+%TeXstudio doesn't like leadsto by default
+\renewcommand{\leadsto}{\rightsquigarrow}
+
+\begin{document}
+
+\begin{center}
+	\huge
+	Algoritmusok és adatszerkezetek II\\
+	\vspace{1mm}
+	\LARGE
+	Gráfok témakör jegyzete\\
+	\vspace{5mm}
+	\large
+	Készült Ásványi Tibor előadásai és gyakorlatai alapján\\
+	\vspace{5mm}
+	Sárközi Gergő, 2021-22-1. félév\\
+	Nincsen lektorálva!
+\end{center}
+
+\tableofcontents
+
+\pagebreak
+
+\section{Egyszerű gráfok és ábrázolásaik}
+
+\subsection{Definíciók}
+
+\subsubsection{Gráf}
+
+\begin{outline}
+	\1 $G=(V,E)$ rendezett pár
+	\1 $V$ a csúcsok véges halmaza
+		\2 $V=\{\}$ üres gráf
+	\1 $E \subseteq V \times V \ \{(u,u) | u \in V\}$ az élek halmaza
+		\2 hurokéleket explicit, párhuzamos éleket implicit kizártuk
+		\2 tehát gráf = egyszerű gráf a továbbiakban
+\end{outline}
+
+\subsubsection{Irányítottság}
+
+\begin{outline}
+	\1 gráf irányítatlan, ha $(u,v) \in E \Leftrightarrow (v,u) \in E$
+	\1 gráf irányított, ha nem következik az egyik a másikból
+	\1 irányított $G=(V,E)$ gráf irányítatlan megfelelője:
+		\2 $G'=(V,E')$ ahol $E'=\{(u,v) | (u,v) \in E \wedge (v,u) \in E\}$
+\end{outline}
+
+\subsubsection{Út}
+
+\begin{outline}
+	\1 út: $<u_0, u_1, u_2, ...,u_n>$ ($u_i \in V$ és $(u_{i-1},u_i) \in E$)
+		\2 ekkor az út hossza $n$ (ami az élek száma is)
+	\1 rész-út: logikusan
+	\1 kör: kezdő és végpontja azonos, $n>0$ és minden éle különböző
+		\2 nincs hurokél: $n \ge 2$
+	\1 körmentes út: nem tartalmaz kört (nincs olyam részútja, ami kör)
+	\1 körmentes gráf: csak körmentes utak vannak benne
+\end{outline}
+
+\pagebreak
+
+\subsubsection{DAG (irányított, körmentes gráf)}
+
+\begin{outline}
+	\1 Directed Acyclic Graph
+\end{outline}
+
+\subsubsection{Összefüggőség}
+
+\begin{outline}
+	\1 G irányítatlan gráf összefüggő, ha mindegyik két csúcsa között van út
+	\1 G irányított gráf összefüggő, ha az irányítatlan megfelelője összefüggő
+	\1 generátor csúcs: ha tetszőleges csúcs elérhető belőle (van út köztük)
+		\2 csak irányított gráfoknál van értelme
+		\2 van generátor csúcs $\implies$ összefüggő (fordítva nem)
+\end{outline}
+
+\subsubsection{Fa}
+
+\begin{outline}
+	\1 szabad fa, irányítatlan fa: irányítatlan, körmentes, összefüggő gráf
+	\1 gyökeres fa, irányított fa: irányított gráf aminek van generátor csúcsa
+	és az irányítatlan megfelőle körmentes
+		\2 ekkor a generátor csúcs a gyökér csúcs
+	\1 nemüres fának pontosan eggyel kevesebb éle van, mint csúcsa
+	\1 erdő: összefüggő komponensei fák (vagy egyetlen fából áll)
+		\2 irányítatlan G gráf erdő $\Leftrightarrow$ G körmentes
+		\2 irányított G gráf erdő $\Leftrightarrow$ G irányítatlan megfelelője körmentes
+		és G mindegyik összefüggő komponensének van generátor csúcsa
+\end{outline}
+
+\subsubsection{Részgráf}
+
+\begin{outline}
+	\1 $G=(V,E)$ gráfnak részgráfja a $G'=(V',E')$ gráf, ha:
+		\2 mindkét gráf irányított vagy mindkét gráf irányítatlan
+		\2 $V' \subseteq V$ és $E' \subseteq E$
+	\1 valódi részgráf: $G \ne G'$
+	\1 diszjunkt részgráfok: nincs közös csúcsok (és ezáltal közös élük sem)
+	\1 összefüggő komponens: olyan részgráf, aminek nincs összefüggő részgráfja
+		\2 minden gráf vagy összefüggő, vagy felbontható diszjunkt összefüggő komponensekre
+\end{outline}
+
+\pagebreak
+
+\subsection{Gráfábrázolás alapjai}
+
+\begin{outline}
+	\1 Legyen $V=\{v_1, v_2, ..., v_n\}$
+	\1 Számok helyett gyakran használunk betűket (a=1, b=2, ...)
+	\1 Legyen $n=|V|$ és $m=|E|$, ekkor $0\le m \le n*(n-1) \le n^2$
+		\2 azaz $m \in O(n^2)$
+		\2 ritka gráf: $m \in O(n)$
+		\2 sűrű gráf: $m \in \Theta(n^2)$
+\end{outline}
+
+\subsection{Grafikus gráfábrázolás}
+
+\begin{outline}
+	\1 Csúcs: kör (bele írjuk a csúcs sorszámát)
+	\1 Irányítatlan él: vonal
+	\1 Irányított él: nyíl
+\end{outline}
+
+\subsection{Szöveges ábrázolás}
+
+\begin{outline}
+	\1 Irányítatlan gráf: $u - u_1 ; u_2 ; u_3 ; ...$
+		\2 $u$ csúcsnak szomszédai a $u_1$, $u_2$, stb. csúcsok
+		\2 nem kell oda-vissza feltünteni (tehát lehet mindent növekvő sorrendben leírni)
+	\1 Irányított gráf: $u \to u_1 ; u_2 ; u_3 ; ...$
+		\2 $u$ csúcsból vezet él a $u_1$, $u_2$, stb. csúcsokba
+\end{outline}
+
+\pagebreak
+
+\subsection{Szomszédossági mátrix (adjacency matrix), avagy csúcsmátrixos ábrázolás}
+
+\begin{outline}
+	\1 $A/1 : bit[n,n]$ mátrix, ahol bit=\{0,1\} és $n=|V|$
+		\2 $A[i,j] = 1 \Leftrightarrow (v_i,v_j) \in E$
+		\2 $A[i,j] = 0 \Leftrightarrow (v_i,v_j) \notin E$
+		\2 $i$ a sor, $j$ az oszlop: sorszámból vezet oszlopszámba él
+	\1 főátlóban mindig 0-k vannak, mert csak egyszerű gráfokkal foglalkozunk
+		\2 $A[i,i] = 0$
+	\1 irányítatlan gráf: főátlóra szimmetrikus mátrix
+		\2 $A[i,j] = A[j,i]$
+		\2 emiatt $n^2$ helyett elég $n*(n-1)/2$ hosszú tömb a mátrix ábrázolására\\
+		(általában az alsó háromszögmátrixot választjuk, főátló nélkül)
+\end{outline}
+
+\subsection{Szomszédossági listás (adjacency list) ábrázolás}
+
+\begin{outline}
+	\1 hasonlít a szöveges reprezentációhoz
+	\1 az i. csúcs szomszédainak sorszámát a $A[i]$ S1L tartalmazza
+		\2 valójában: $A/1 : Edge*[n]$, ahol $Edge$ tagjai: $v$, $next$
+	\1 irányítatlan gráfok esetén minden él így kétszer van tárolva
+	\1 tárigénye: $n$ db mutató, listáknak összesen $m$ vagy $2*m$ elem
+		\2 azaz mindkét esetben $\Theta(n+m)$
+		\2 ritka gráf: $\Theta(n)$ (mert $m \in O(n)$)
+		\2 sűrű gráf: $\Theta(n^2)$ (mert $m \in O(n^2)$)
+\end{outline}
+
+\pagebreak
+
+\section{Absztrakt halmaz, sorozat, gráf}
+
+\subsection{Absztrakt halmaz}
+
+\begin{outline}
+	\1 $T$ típusú véges halmaz: $T\{\}$
+	\1 $s : T\{\}$ egy üres halmaz, $s : T\{a,b,c\}$ egy 3 elemű halmaz
+	\1 kiválasztás (tetszőleges elem eltávolítása): $u \;from\; S$
+		\2 $S$ egy nemüres halmaz
+		\2 $S$-ből eltávolítunk egy elemet és ezt $u$ értékül kapja
+\end{outline}
+
+\subsection{Absztrakt sorozat}
+
+\begin{outline}
+	\1 $T$ típusú véges sorozat: $T<>$
+	\1 $s : T<>$ egy üres sorozat, $s : T<a,b,c>$ egy 3 elemű sorozat
+	\1 1-től indexeljük őket
+	\1 ha $u,v : T<>$ akkor $u+v$ a konkatenálás
+\end{outline}
+
+\subsection{Absztrakt gráf}
+
+\begin{outline}
+	\1 $\mathcal{V}$: vertex (csúcs) típus
+		\2 tetszőlegesen sok, névvel jelölt, értékkel ellátott címkét tárol
+		\2 legyen $v$ csúcs, $name$ a címke neve, ekkor $name(v)$ a címke értéke
+	\1 $\mathcal{E}$: edge (él) típus, adattagjai: $u,v : \mathcal{V}$
+	\1 $\mathcal{G}$: élsúlyozatlan absztrakt gráf
+		\2 adattagok: $V:\mathcal{V}\{\}$ és $E:\mathcal{E}\{\}$
+		\2 $V$ véges
+		\2 $E \subseteq V \times V \setminus \{(u,u) | u \in V\}$
+\end{outline}
+
+\pagebreak
+
+\section{Elemi gráfalgoritmusok}
+
+\begin{outline}
+	\1 gráfok nincsenek élsúlyozva
+\end{outline}
+
+\subsection{BFS (szélességi gráfkeresés)}
+
+\begin{outline}
+	\1 irányított és irányítatlan gráfokra is értelmezett
+	\1 egy adott csúcsból ($s$) meghatározza az összes másik csúcsba vezető legrövidebb utat
+	\1 használt címkék:
+		\2 $d$: távolság a kezdő csúcstól
+		\2 $\pi$: "szülő", azaz a kezdő csúcs felé levő úton az első csúcs
+			\3 $\pi(s)=\emptyset$
+		\2 ha $u$ egy el nem érhető csúcs: $pi(u)=\emptyset$ és $d(u)=\infty$
+		\2 $color$: csak vizualizáció miatt
+			\3 fehér: még nincs megtalálva
+			\3 szürke: feldolgozásra vár
+			\3 fekete: feldolgozva
+	\1 indeterminisztikus esetekben a kisebb címkéjű csúcsot válasszuk
+	\1 időkomplexitás
+		\2 legyen $n=|G.V|$ és $m=|G.E|$
+		\2 $MT(n,m) \in \Theta(n+m)$ (2. ciklus max m-szer iterál)
+			\3 szomszédossági listás ábrázolás esetén: $\Theta(n^2)$
+		\2 $mT(n,m) \in \Theta(n)$ (2. ciklus min egyszer iterál)
+\end{outline}
+
+\pagebreak
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.5\linewidth]{bfs}
+\end{figure}
+
+\subsubsection{Szélességi fa (Breadth-first tree)}
+
+\begin{outline}
+	\1 ha $\pi(u)=v$-t úgy értelmezzük, hogy $v$ szüleje $u$-nak, akkor fát kapunk
+	\1 más néven: legrövidebb utak fája
+\end{outline}
+
+\pagebreak
+
+\subsection{DFS (Mélységi gráfkeresés)}
+
+\begin{outline}
+	\1 egyszerű, irányított gráfokra értelmezett
+	\1 használt címkék:
+		\2 d: elérési idő (discovery time)
+		\2 f: befejezési idő (finishing time)
+		\2 $\pi$: "szülő", azaz a kezdő csúcs felé levő úton az első csúcs
+			\3 $\emptyset$, ha egy mélységi fa gyökere
+		\2 color: (nem kihagyható)
+			\3 fehér: érintetlen
+			\3 szürke: belőle elérhető csúcsokat járunk be éppen
+			\3 fekete: feldolgozva
+	\1 DFSvisit mélységi fát számol ki, DFS pedig mélységi feszítő erdőt
+	\1 time akkor lép, amikor elérünk vagy befejezünk egy csúcsot
+		\2 az első time érték = 1
+	\1 backEdge(u,v): tetszőleges eljárás, tegyük fel, hogy $\Theta(1)$
+	\1 időkomplexitás:
+		\2 legyen $n=|G.V|$ és $m=|G.E|$
+		\2 DFSvisit n-szer hívódik, de a ciklusa ÖSSZESEN csak m-et iterál
+		\2 $MT(n,m),mT(n,m) \in \Theta(n+m)$
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.85\linewidth]{dfs}
+\end{figure}
+
+\pagebreak
+
+\subsubsection{Élek osztályozása}
+
+\begin{outline}
+	\1 (u,v) fa-él (tree edge): (u,v) valamelyik mélységi fa éle.\\
+	(Ezen élek mentén járjuk be a gráfot.)
+	\1 (u,v) vissza-él (back edge): v az u őse, de nem faél.
+		\2 Ez azt jelenti, hogy irányított kört találtunk.
+	\1 (u,v) előre-él (forward edge): v az u leszármazottja, de nem faél.
+	\1 (u,v) kereszt-él (cross edge): u és v két olyan csúcs, amelyek vagy azonos mélységi fa két különböző ágán vannak, vagy két különböző mélységi fában vannak.
+\end{outline}
+
+\subsubsection{Élek felismerése}
+
+Mélységi bejárás során az (u,v) él feldolgozásakor:\\
+(Ha szöveges címkét rendelnénk a feldolgozás során, így tennénk.)
+
+\begin{outline}
+	\1 (u,v) fa-él: v csúcs még fehér
+	\1 (u,v) vissza-él: v csúcs éppen szürke
+	\1 (u,v) előre-él: v csúcs már fekete és $d(u) < d(v)$
+	\1 (u,v) kereszt-él: v csúcs már fekete és $d(u) > d(v)$
+\end{outline}
+
+\subsubsection{Bejárás szemléltetése}
+
+\begin{outline}
+	\1 Élek: dupla a fa él, többi betűvel jelölve
+	\1 csúcsnál x/y: d(u) / f(u)
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.5\linewidth]{dfs-példa}
+\end{figure}
+
+\pagebreak
+
+\subsubsection{DAG tulajdonság eldöntése}
+
+\begin{outline}
+	\1 $G$ irányított gráf akkor Directed Acyclic Graph, ha nem tartalmaz irányított kört
+	\1 DFS fog találni vissza-élt, ha van irányított kör a gráfban
+		\2 viszont nem fog annyi vissza-élt találni, ahány irányított kör van:
+		egy él lehet több kör része is
+	\1 $(u,v)$ vissza-él $\implies$ $<u,v,...,\pi(\pi(u)),\pi(u),u>$ egy irányított kör
+		\2 ezt a kört az algoritmus a fordított sorrendben találná meg
+	\1 a backEdge eljárás hasznos eme infó lementése céljából
+\end{outline}
+
+\subsubsection{Topologikus rendezés}
+
+\begin{outline}
+	\1 Topologikus rendezés: gráf csúcsainak olyan sorba rendezése, hogy minden él egy későbbi csúcsba mutasson. (Pl. minden él balról jobbra.)
+	\1 Irányított gráfnak lehet 0, 1 vagy több féle topologikus rendezése.
+	\1 Irányított gráfnak pontosan akkor van topologikus rendezése, ha DAG.
+	\1 Mélységi bejárás segítségével topologikus rendezés:
+		\2 csúcsok $f(u)$ szerint csökkenő rendezése
+		\2 vagy csúcsokat befejezésükkör rakjuk egy verembe
+\end{outline}
+
+\pagebreak
+
+\section{Élsúlyozott gráfok és ábrázolásaik}
+
+\subsection{Absztrakt ábrázolás}
+
+\begin{outline}
+	\1 $\mathcal{V}$: vertex (csúcs) típus, címkéket tárol, lásd normál gráf
+	\1 $\mathcal{E}$: edge (él) típus, adattagjai: $u,v : \mathcal{V}$
+	\1 $\mathcal{G}_w$: élsúlyozott absztrakt gráf
+		\2 adattagok: $V:\mathcal{V}\{\}$, $E:\mathcal{E}\{\}$ és $w:E \to \mathbb{R}$
+		\2 $V$ véges
+		\2 $E \subseteq V \times V \setminus \{(u,u) | u \in V\}$
+		\2 $w$ a súlyfüggvény
+\end{outline}
+
+\subsection{Emlékeztető}
+
+\begin{outline}
+	\1 $n=|V|$ és $m=|E|$
+	\1 $0 \le m \le n*(n-1) \le n^2$
+	\1 ritka gráf: $m \in O(n)$
+	\1 sűrű gráf: $m \in \Theta(n^2)$
+\end{outline}
+
+\subsection{Grafikus ábrázolás}
+
+\begin{outline}
+	\1 Csúcs: kör (bele írjuk a csúcs sorszámát)
+	\1 Irányítatlan él: vonal; irányított él: nyíl
+	\1 Élek mellé odaírjuk a súlyukat
+\end{outline}
+
+\subsection{Szöveges ábrázolás}
+
+\begin{outline}
+	\1 Irányítatlan gráf: $v - v_1, w_1 ; v_2, w_2 ; ...$
+		\2 $v$ csúcsnak szomszédai a $v_i$ csúcsok, az él súlya $w_i$
+		\2 nem kell oda-vissza feltünteni (tehát lehet mindent növekvő sorrendben leírni)
+	\1 Irányított gráf: $v \to v_1, w_1 ; v_2, w_2 ; ...$
+		\2 $u$ csúcsból vezet él a $u_i$ csúcsokba, $w_i$ élsúllyal
+\end{outline}
+
+\pagebreak
+
+\subsection{Szomszédossági mátrix, csúcsmátrix, adjacency matrix}
+
+\begin{outline}
+	\1 $A\rightarrow : \mathbb{R}_\infty[n,n]$ ahol $n=|V|$
+		\2 $A[i,i] = 0$ (egyszerű gráf)
+		\2 $A[i,j] = \infty \Leftrightarrow (v_i,v_j) \notin E$
+		\2 $A[i,j] = w(v_i,v_j) \Leftrightarrow (v_i,v_j) \in E$
+		\2 i a sor, j az oszlop: sorszámból vezet oszlopszámba él
+	\1 Irányítatlan gráf: főátlóra szimmetrikus
+	\1 Tárigény $\Theta(n^2)$ (ha egy $\mathbb{R}_\infty$ konstans hosszú)
+\end{outline}
+
+\subsection{Szomszédossági lista, adjacency list}
+
+\begin{outline}
+	\1 Hasonlít a szöveges reprezentációhoz
+	\1 $A:Edge*[n]$ ahol $n=|V|$ ($A$ egy S1L)
+		\2 $Edge$ adattagjai: $v:\mathbb{N}; \;\; w:\mathbb{R}; \;\; next:Edge*$
+	\1 Irányítatlan gráfok esetén minden él így kétszer van tárolva
+	\1 Tárigény: $n$ db mutató, listáknak összesen $m$ vagy $2 * m$ elem
+		\2 ritka gráf: $\Theta(n)$ (mert $m \in O(n)$)
+		\2 sűrű gráf: $\Theta(n^2)$ (mert $m \in O(n^2)$)
+\end{outline}
+
+\pagebreak
+
+\section{Minimális feszítőfák, Minimum Spanning Tree}
+
+\begin{outline}
+	\1 $G=(V,E)$ irányítatlan gráf feszítő erdeje $T=(V,F)$, ahol $F \subseteq E$
+		\2 azaz $T$ minden komponense fa, amik páronként diszjunktak
+	\1 Legyen $w(G)$ az $E$ élek súlyösszege
+		\2 $T$ a $G$ MST-je, ha $T$ a $G$ feszítőfája és bármely $T'$ feszítőfára $w(T) \le w(T')$
+	\1 Mohó modszerrel, $O(m*\lg n)$ időben számolható (Kruskal és Prim)
+\end{outline}
+
+\subsection{Általános algoritmus}
+
+\begin{outline}
+	\1 $A:\mathcal{E}\{\}$ kezdetben üres, végig $G$ egy feszítőfájának élhalmazának részhalmaza
+	\1 Minden lépésben egy biztonságos $(u,v)$ élt adunk $A$-hoz: olyan élt, amivel az előbbi állítás (invariáns) igaz marad
+	\1 Addig fut az algoritmus, amíg $|A| \ne |G.V|-1$
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.65\linewidth]{GenMST}
+\end{figure}
+
+\pagebreak
+
+\subsubsection{Vágás (nem tűnik fontosnak)}
+
+\begin{outline}
+	\1 $G=(V,E)$ gráf, $\{\} \subset S \subset V$
+	\1 Vágás G-n: $(S, V \setminus S)$
+	\1 $(u,v) \in E$ él keresztezi a $(S, V \setminus S)$ vágást, ha $u \in S = v \in V \setminus S$
+		\2 azaz ha $(u \in S \wedge v \in V \setminus S) \lor (u \in V \setminus S \wedge v \in S)$
+	\1 $(u,v) \in E$ könnyű él egy vágásban, ha
+		\2 $(u,v)$ keresztezi a vágást
+		\2 és $\forall(p,q)$ vágást keresztező élre $w(u,v) \le w(p,q)$
+	\1 $A \subseteq E$ élhalmaz elkerüli a vágást, ha $A$ egyetlen éle sem keresztezi azt
+\end{outline}
+
+\subsubsection{Tétel biztongságos élre (nem tűnik fontosnak)}
+
+\begin{outline}
+	\1 Legyen $g=(V,E)$ irányítatlan, összefüggő, élsúlyozott gráf
+	\1 $A$ részhalmaza G valamelyik minimális feszítőfájának élhalmazának
+	\1 $(S,V \setminus S)$ vágás elkerüli az $A$ élhalmazt
+	\1 $(u,v) \in E$ könnyű él a $(S,V \setminus S)$ vágásban
+	\1 Ekkor $(u,v)$ biztonságos él; hozzávehető $A$-hoz
+	\1 Bizonyítás: nem nagyon értem, nem tűnik fontosnak, de jegyzetben
+\end{outline}
+
+\pagebreak
+
+\subsection{Kruskal algoritmusa}
+
+\begin{outline}
+	\1 Legyen $G=(V,E)$ összefüggő, irányítatlan, élsúlyozott gráf
+	\1 Invariáns: $(V,A)$ a $G$ egy feszítő erdeje és $A$ részhalmaza $G$ egy MST-jének élhalmazának
+	\1 Kezdetben $A=\{\}$. Az éleket súlyuk szerint növekvő sorrendben dolgozzuk fel. Minden új éllel két fát kötünk össze, így a fák száma mindig csökken. Amennyiben egy él nem volt biztonságos, eldobjuk.
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.9\linewidth]{kruskal-példa}
+\end{figure}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.9\linewidth]{kruskal}
+\end{figure}
+
+\pagebreak
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.9\linewidth]{kruskal-halmaz}
+\end{figure}
+
+\begin{outline}
+	\1 Az irányítatlan feszítőerdő mellett egy irányított erdőt is kezelünk. Ez az irányított erdő a "gyökere felé mutat".
+	\1 $\pi$ címke: szülő csúcsot tárolja, gyökérre viszont $\pi(r)=r$
+	\1 $s(r)$ az $r$ gyökérhez tartozó fa mérete
+	\1 $union$ mindig a kisebbet fűzi be a nagyobb-egyenlő gyökerébe közvetlenül. Így sosem lesz a fák magassága nagyobb, mint méretük $\log_2$. Ezért lesz a $findSet$ hatékony.
+\end{outline}
+
+\pagebreak
+
+\subsection{Prim algoritmusa}
+
+\begin{outline}
+	\1 Legyen $G=(V,E)$ összefüggő, irányítatlan, élsúlyozott gráf
+	\1 Invariáns: $T=(N,A)$ mindig $G$ egy MST-jének része
+	\1 $A$-hoz mindig olyan biztonságos élet adunk hozzá, amelyik él egy $A$-beli és $A$-n kívüli csúcsot köt össze.
+	\1 Kezdetben tetszőleges csúcsból indulunk. ($N=\{r\}; \; A=\{\}$)
+	\1 Minden $V \setminus N$ csúcshoz tartozik $c$ és $p$ címke, ha van él köztük és a $N$ egyik csúcsa között (azaz a $(N,V \setminus N)$ vágásban)
+		\2 $p(u)$: egy vágásban lévő él másik csúcsa; az él: $(p(u),u)$
+		\2 $c(u)$: az él súlya; $c(u)=w(p(u),u)$
+		\2 mindez úgy, hogy $\forall (x,u)$ vágásbeli élre $w(x,u) \ge w(p(u),u)$
+	\1 Ha nincs él $u$ és $N$ egy csúcsa között sem: $p(u)=\emptyset$ és $c(u)=\infty$
+	\1 $A$-hoz mindig a $c(u)$ szerint legkisebb élet adjuk hozzá.
+		\2 Egy min prioritásos sorban tároljuk az $u$ csúcsokat.
+		\2 Egy ilyen hozzáadáskor frissíteni kell a $c(v)$ értékeket minden olyan $v$-re, amelyik szomszédja $u$-nak.
+	\1 A végső fa élei $(p(x),x)$, ahol $x \in V \setminus \{r\}$ (csúcshalmaza pedig $V$)
+\end{outline}
+
+\pagebreak
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=1\linewidth]{prim}
+\end{figure}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=1\linewidth]{prim-példa}
+\end{figure}
+
+\pagebreak
+
+\section{Legrövidebb utak egy forrásból}
+
+\begin{outline}
+	\1 Adott $s$ csúcsból minden $s$-ből elérhető csúcsba legrövidebb utat keresünk.
+	\1 Értelmezzük az irányítatlan gráfot olyan irányított gráfként,\\
+	ahol $(u,v) \in E \implies (v,u) \in E \wedge w(u,v) = w(v,u)$
+	\1 Pontosan akkor oldható meg, ha nem létezik $s$-ből elérhető negatív kör
+		\2 Negatív kör: olyan kör, amelynek összsúlya negatív
+		\2 Irányítatlan gráfok esetén akkor is lesz ilyen "kör", ha van negatív súlyú él.
+	\1 Ha megoldható, mindegyik $v \in V \setminus \{s\}$-re két lehetőség van:
+		\2 Létezik út $s$-ből $v$-be:
+			\3 $d(v)$ az optimális út hossza
+			\3 $\pi(v)$ az optimális úton $v$-t közvetlenül megelőző csúcs
+		\2 Nem létezik út $s$-ből $v$-be: $d(v)=\infty$ és $\pi(v)=\emptyset$
+		\2 $s$ csúcsra: $d(s)=0$ és $\pi(s)=\emptyset$
+	\1 Az algoritmusok az optimális utat folyamatosan közelítik, $d(v)=\infty$ és $\pi(v)=\emptyset$-ből indulva. Jelölje $s \leadsto v$ azt a kiszámolt utat, ami az eddigi legjobb; ekkor $d(v)\in \mathbb{R}$ és $v \ne s$ esetén $\pi(v) \ne \emptyset$. Gráf éleit folyamatosan vizsgáljuk és ha pl. $(u,v)$-t nézzük éppen és $s\leadsto u \to v$ rövidebb,
+	mint $s \leadsto v$, akkor frissítjük: közelítjük (relaxation).
+	\1 Az algoritmusok közös vonása, hogy egy feldolgozandó csúcsok halmazából minden lépésben kivesznek egy csúcsot és az összes kimenő élre elvégzik a közelítést. A közelítéseket a csúcs kiterjesztésének nevezzük. A csúcs kivételét és a kiterjesztést együtt pedig a csúcs feldolgozásának.
+\end{outline}
+
+\pagebreak
+
+\subsection{Dijkstra algoritmusa}
+
+\begin{outline}
+	\1 Előfeltétel: mindegyik él súlya nemnegatív
+	\1 Nagyon hasonlít Prim algoritmusára, mohó
+		\2 $MT \in O((n+m)*\lg n)$ (magyarázat: Prim algoritmusa)
+		\2 $mT \in \Theta(n)$ (ha $s$-nek nincs rákövetkezője)
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.9\linewidth]{dijkstra}
+\end{figure}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=1\linewidth]{dijkstra-példa}
+\end{figure}
+
+\begin{outline}
+	\1 $u:=Q.remMin()$-nél $s \leadsto u$ optimális ha $d(u) \ne \infty$. Bizonyítás indirekt módon, jegyzetben.
+	\1 Ha $u:=Q.remMin()$-nél $d(u) = \infty$ akkor $Q$ egy eleme sem érhető el $s$-ből.
+	% Bizonyítás: mindig a minimális súlyút vesszük ki a sorból, tehát ha $d(u)=\infty$ akkor egy csúcs $d$ értéke sem fog csökkenni. Tehát ha $d(u)$ volt a legkisebb, akkor már minden maradék $Q$-beli csúcs elérhetetlen.
+\end{outline}
+
+\pagebreak
+
+\subsection{DAGshP (DAG shortest Paths)}
+
+\begin{outline}
+	\1 Előfeltétel: irányított a gráf és nincs benne irányított kör
+	\1 Az algoritmus ellenőrzi az előfeltételét:
+		\2 nincs irányított kör: $\emptyset$-tel tér vissza
+		\2 különben a kör egy csúcsával tér vissza, ami a $\pi$ címkék mentén fordított irányban bejárható
+	\1 $MT \in \Theta(n+m)$ és $mT \in \Theta(n)$
+	\1 A $topologicalSort$ csak az $s$-ből elérhető részgráfot teszi be $S$-be, a megfelelő sorrendben.
+	\1 A $time$ változó globális, de csak szemléltetésre van, elhagyható.
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=1\linewidth]{DAGshP-példa}
+\end{figure}
+
+\pagebreak
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=1\linewidth]{DAGshP}
+\end{figure}
+
+\pagebreak
+
+\subsection{Sor-alapú Bellman-Ford algoritmus (QBF)}
+
+\begin{outline}
+	\1 Nem mohó
+	\1 Előfeltétel: nincs $s$-ből elérhető negatív kör.
+	\1 Előfeltétel ellenőrzése algoritmusban:
+		\2 $e(v)$ címke: $s \leadsto v$ út élszáma (NEM súlya!)
+		\2 nincs negatív kör: $e(v) < n$ és $\emptyset$ a visszatérési érték
+		\2 $e(v) \ge n \implies$ $v$ része egy negatív körnek, vagy $\pi(v)$-n keresztül negatív körbe érkezünk (max $n$ lépésben megoldható), a kör egyik csúcsa a visszatérési érték
+	\1 $MT = O(n*m)$
+		\2 gyakorlatban átlagosan $\Theta(n)$, ha ritka a gráf ($m \in O(n)$)
+	\1 Új címke: $inQ$ (benne van-e a sorban, bit tömbbel megvalósítható)
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=1\linewidth]{QBF-példa-jó}
+\end{figure}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=1\linewidth]{QBF-példa-kör}
+\end{figure}
+
+\pagebreak
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.7\linewidth]{QBF}
+\end{figure}
+
+\begin{outline}
+	\1 Menet:
+		\2 0.: $s$ feldolgozása
+		\2 $(i+1)$.: $i$. menet lévén sorban lévő csúcsok feldolgozása
+	\1 Ha $s$-ből nem érhető el negatív kör:
+		\2 Ha $s \leadsto u$ optimális út $k$ élből áll, akkor a k. menet elején már megtalálta az algoritmus.
+		\2 Minden optimális út max $n-1$ hosszú $\implies$ n-1. menet végére kiürül a sor. Innen jön $MT \in O(n*m)$.
+\end{outline}
+
+\pagebreak
+
+\section{Legrövidebb utak minden csúcspárra}
+
+\subsection{Floyd-Warshall (FW) algoritmus}
+
+\begin{outline}
+	\1 Legyen $\mathbb{R}_\infty = \mathbb{R} \cup \{\infty\}$, ahol $\infty$ jelentése: nincs él/út
+	\1 Mátrixok kiolvasása, $A[i,j]$ jelentése: $i$-ből (sor) $j$-be (oszlop) valami
+	\1 Bemenet: élsúlyozott gráf egy $A/1: \mathbb{R}_\infty[n,n]$ csúcsmátrixként
+	\1 Kimenet:
+		\2 Utak hossza: $D/1: \mathbb{R}_\infty[n,n]$
+		\2 Útban a csúcs megelőzője: $\pi/1: \mathbb{N}[n,n]$
+			\3 Ha nincs út, vagy $i=j$ akkor: $\pi[i,j]=\emptyset$
+	\1 Előfeltétel (ellenőrzi magától): gráfban nincs negatív kör
+		\2 Visszatér egy negatív körbeli csúccsal, ha van ilyen.
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.7\linewidth]{FloydWarshall}
+\end{figure}
+
+\begin{outline}
+	\1 Műveletigény: $MT(n) \in \Theta(n^3)$
+		\2 Ha van negatív kör, akkor $mT(n) \in \Theta(n^2)$ \; (egyébként $\Theta(n^3)$)
+\pagebreak
+	\1 Megoldás módszere: dinamikus programozás
+		\2 két csúcs ($i$ és $j$) között az első $k$ csúcs felhasználásával keresünk utat
+		($i > k$ és $j > k$ megengedett)
+		\2 $\exists i \leadsto^0_{opt} j$ ha $(i,j) \in G.E$ \;\; (ekkor az út: $<i,j>$)
+		\2 $\forall k \in 1..n: i \leadsto^{k}_{opt} j$ vagy $i \leadsto^{k-1}_{opt} j$
+		vagy $i \leadsto^{k-1}_{opt} k \leadsto^{k-1}_{opt} j$
+		\2 Ha az $i$-ből $i$-be vezető optimális út súlya negatív, akkor (és csak akkor) van negatív kör és ekkor $i$ a negatív kör része.
+\end{outline}
+
+\subsection{Visszavezetés az "utak egy forrásból" feladatra}
+
+\begin{outline}
+	\1 Floyd-Warshall algoritmus $D$ és $\pi$ mátrixának $i$-edik sora a "legrövidebb utak egy forrásból" feladat megoldása $s=i$ esetre, valamint fordítva.
+	\1 Fontos: a DAG és Dijkstra algoritmusok előfeltétele szigorúbb.
+	\1 A DAG algoritmus $n$-szer meghívva: $MT \in \Theta(n*(n+m))$
+		\2 Ritka gráfon aszimptotikusan jobb: $\Theta(n^2)$
+		\2 Sűrű gráfon egyenlő ($\Theta(n^3)$), gyakorlatban lassabb
+	\1 Dijkstra algoritmust $n$-szer meghívva: $MT \in \Theta(n*(n+m)*\log n)$
+		\2 Ritka gráf: $\Theta(n^2*\log n)$ (tehát jobb)
+		\2 Sűrű gráf: $\Theta(n^3*\log n)$ (tehát rosszabb)
+	\1 QBF algoritmust $n$-szer meghívva: $MT \in \Theta(n^2*m)$
+		\2 Ez soha nem jobb, legkedvezőbb esetben aszomptotikusan azonos
+\end{outline}
+
+\pagebreak
+
+\section{Gráf tranzitív lezártja (Transitive Closure)}
+
+\begin{outline}
+	\1 Gráfban honnét hova lehet eljutni (konkrét út és súly lényegtelen)
+	\1 $G=(V,E)$ tranzitív lezártja a $T \subseteq V \times V$ reláció, ahol:\\
+	$(u,v) \in T \Leftrightarrow$ $G$-ben az $u$ csúcsból elérhető a $v$ csúcs
+\end{outline}
+
+\subsection{Egyszerű algoritmus}
+
+\begin{outline}
+	\1 Bemenet: gráf egy $A/1:\mathbb{B}[n,n]$ csúcsmátrixként
+	\1 Kimenet: $T/1:\mathbb{B}[n,n]$ ahol $T[i,j]=$ van út $i$-ből (sor) $j$-be (oszlop)
+	\1 Megoldási módszer: dinamikus programozás, $mT=MT \in \Theta(n^3)$
+		\2 $T^{(0)}_{i,j}=\exists i \leadsto j$ az első $k$ csúcsot használva csak ($i,j>k$ szabad)
+		\2 $T^{(0)}_{i,j}=A[i,j] \lor (i=j)$
+		\2 $T^{k}_{i,j}=T^{k-1}_{i,j} \lor (T^{k-1}_{i,k} \wedge T^{k-1}_{k,j})$
+	\1 Floyd-Warshall kimenetből megadható: $T[i,j] = D[i,j] < \infty$\\
+	(de FW-nek van előfeltétele és gyakorlatban nem annyira hatékony)
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.7\linewidth]{TransitiveClosure}
+\end{figure}
+
+\subsection{Visszavezetés szélességi keresésre}
+
+\begin{outline}
+	\1 A kimeneti mátrix $i$-edik sora a BFS $s=i$ kimenetéből kiszámolható:\\
+	$\forall j: T[i,j] \Leftrightarrow \pi(j) \ne \emptyset$ \;\;
+	(vagy $color(j) \ne white$ vagy $d(j) \ne \infty$)
+	\1 BFS $n$-szeri lefuttatása: $MT \in \Theta(n*(n+m))$
+		\2 Ritka gráfon aszimptotikusan jobb: $\Theta(n^2)$
+		\2 Sűrű gráfon egyenlő ($\Theta(n^3)$), gyakorlatban lassabb
+\end{outline}
+
+\end{document}
diff --git "a/algo2/gr\303\241f/bfs.jpg" "b/algo2/gr\303\241f/bfs.jpg"
new file mode 100644
index 0000000..11e5df1
Binary files /dev/null and "b/algo2/gr\303\241f/bfs.jpg" differ
diff --git "a/algo2/gr\303\241f/dfs-p\303\251lda.jpg" "b/algo2/gr\303\241f/dfs-p\303\251lda.jpg"
new file mode 100644
index 0000000..a462208
Binary files /dev/null and "b/algo2/gr\303\241f/dfs-p\303\251lda.jpg" differ
diff --git "a/algo2/gr\303\241f/dfs.jpg" "b/algo2/gr\303\241f/dfs.jpg"
new file mode 100644
index 0000000..bcdb6d7
Binary files /dev/null and "b/algo2/gr\303\241f/dfs.jpg" differ
diff --git "a/algo2/gr\303\241f/dijkstra-p\303\251lda.png" "b/algo2/gr\303\241f/dijkstra-p\303\251lda.png"
new file mode 100644
index 0000000..07942a8
Binary files /dev/null and "b/algo2/gr\303\241f/dijkstra-p\303\251lda.png" differ
diff --git "a/algo2/gr\303\241f/dijkstra.png" "b/algo2/gr\303\241f/dijkstra.png"
new file mode 100644
index 0000000..f52e06e
Binary files /dev/null and "b/algo2/gr\303\241f/dijkstra.png" differ
diff --git "a/algo2/gr\303\241f/kruskal-halmaz.png" "b/algo2/gr\303\241f/kruskal-halmaz.png"
new file mode 100644
index 0000000..9996ccf
Binary files /dev/null and "b/algo2/gr\303\241f/kruskal-halmaz.png" differ
diff --git "a/algo2/gr\303\241f/kruskal-p\303\251lda.png" "b/algo2/gr\303\241f/kruskal-p\303\251lda.png"
new file mode 100644
index 0000000..9812181
Binary files /dev/null and "b/algo2/gr\303\241f/kruskal-p\303\251lda.png" differ
diff --git "a/algo2/gr\303\241f/kruskal.png" "b/algo2/gr\303\241f/kruskal.png"
new file mode 100644
index 0000000..b9dc4e1
Binary files /dev/null and "b/algo2/gr\303\241f/kruskal.png" differ
diff --git "a/algo2/gr\303\241f/prim-p\303\251lda.png" "b/algo2/gr\303\241f/prim-p\303\251lda.png"
new file mode 100644
index 0000000..f5eb345
Binary files /dev/null and "b/algo2/gr\303\241f/prim-p\303\251lda.png" differ
diff --git "a/algo2/gr\303\241f/prim.png" "b/algo2/gr\303\241f/prim.png"
new file mode 100644
index 0000000..d2b373f
Binary files /dev/null and "b/algo2/gr\303\241f/prim.png" differ
diff --git "a/algo2/mintailleszt\303\251s/BruteForce.png" "b/algo2/mintailleszt\303\251s/BruteForce.png"
new file mode 100644
index 0000000..9954a44
Binary files /dev/null and "b/algo2/mintailleszt\303\251s/BruteForce.png" differ
diff --git "a/algo2/mintailleszt\303\251s/KMP-p\303\251lda-init.png" "b/algo2/mintailleszt\303\251s/KMP-p\303\251lda-init.png"
new file mode 100644
index 0000000..acdcf6f
Binary files /dev/null and "b/algo2/mintailleszt\303\251s/KMP-p\303\251lda-init.png" differ
diff --git "a/algo2/mintailleszt\303\251s/KMP-p\303\251lda-kmp.png" "b/algo2/mintailleszt\303\251s/KMP-p\303\251lda-kmp.png"
new file mode 100644
index 0000000..632abec
Binary files /dev/null and "b/algo2/mintailleszt\303\251s/KMP-p\303\251lda-kmp.png" differ
diff --git "a/algo2/mintailleszt\303\251s/KMP.png" "b/algo2/mintailleszt\303\251s/KMP.png"
new file mode 100644
index 0000000..b9470fb
Binary files /dev/null and "b/algo2/mintailleszt\303\251s/KMP.png" differ
diff --git "a/algo2/mintailleszt\303\251s/QuickSearch-p\303\251lda-shift.png" "b/algo2/mintailleszt\303\251s/QuickSearch-p\303\251lda-shift.png"
new file mode 100644
index 0000000..dd915bb
Binary files /dev/null and "b/algo2/mintailleszt\303\251s/QuickSearch-p\303\251lda-shift.png" differ
diff --git "a/algo2/mintailleszt\303\251s/QuickSearch-p\303\251lda-t\303\241bl\303\241zat.png" "b/algo2/mintailleszt\303\251s/QuickSearch-p\303\251lda-t\303\241bl\303\241zat.png"
new file mode 100644
index 0000000..d2136bf
Binary files /dev/null and "b/algo2/mintailleszt\303\251s/QuickSearch-p\303\251lda-t\303\241bl\303\241zat.png" differ
diff --git "a/algo2/mintailleszt\303\251s/QuickSearch.png" "b/algo2/mintailleszt\303\251s/QuickSearch.png"
new file mode 100644
index 0000000..3bebe6d
Binary files /dev/null and "b/algo2/mintailleszt\303\251s/QuickSearch.png" differ
diff --git "a/algo2/mintailleszt\303\251s/algo2-mintailleszt\303\251s.pdf" "b/algo2/mintailleszt\303\251s/algo2-mintailleszt\303\251s.pdf"
new file mode 100644
index 0000000..ad6e78e
Binary files /dev/null and "b/algo2/mintailleszt\303\251s/algo2-mintailleszt\303\251s.pdf" differ
diff --git "a/algo2/mintailleszt\303\251s/algo2-mintailleszt\303\251s.tex" "b/algo2/mintailleszt\303\251s/algo2-mintailleszt\303\251s.tex"
new file mode 100644
index 0000000..d459394
--- /dev/null
+++ "b/algo2/mintailleszt\303\251s/algo2-mintailleszt\303\251s.tex"
@@ -0,0 +1,200 @@
+% !TeX spellcheck = hu_HU
+\documentclass[12pt,a4paper]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{cmap}
+\usepackage[T1]{fontenc}
+\usepackage[magyar]{babel}
+\usepackage{amsmath}
+\usepackage{amsfonts}
+\usepackage{amssymb}
+\usepackage{graphicx}
+
+\usepackage{struktex}
+\usepackage{outlines}
+\usepackage{hyperref}
+
+\hyphenpenalty=10000
+
+%TeXstudio doesn't like leadsto by default
+\renewcommand{\leadsto}{\rightsquigarrow}
+
+\begin{document}
+
+\begin{center}
+	\huge
+	Algoritmusok és adatszerkezetek II\\
+	\vspace{1mm}
+	\LARGE
+	Mintaillesztés témakör jegyzete\\
+	\vspace{5mm}
+	\large
+	Készült Ásványi Tibor előadásai és gyakorlatai alapján\\
+	\vspace{5mm}
+	Sárközi Gergő, 2021-22-1. félév\\
+	Nincsen lektorálva!
+\end{center}
+
+\tableofcontents
+
+\pagebreak
+
+\section{Mintaillesztés}
+
+\begin{outline}
+	\1 Abécé: $\Sigma = \{\sigma_1, \sigma_2, ..., \sigma_d\}$ \;\; ($1 \le d < \infty$ konstans)
+	\1 Szöveg, amiben keresünk: $T/1: \Sigma[n]$ \;\; ($1 \le n$)
+	\1 Minta, amit keresünk: $P/1: \Sigma[m]$ \;\; ($1 \le m \le n$)
+	\1 $s \in 0..(n-m)$ $P$ érvényes eltolása $T$-n $\Leftrightarrow T[s+1..s+m] = P[1..m]$
+	\1 A cél az érvényes eltolások $S$ halmazának megállapítása
+\end{outline}
+
+\section{Egyszerű (brute force) algoritmus}
+
+\begin{outline}
+	\1 Minden lehetséges $s$ értékre, egymástól függetlenül, próbáljuk a mintát
+	\1 Időkomplexitás: $MT(n,m) \in \Theta(n*m)$ és $mT(n,m) \in \Theta(n)$
+		\2 Alapból $MT \in \Theta((n-m+1)*m)$ és $mT \in \Theta(n-m+1)$
+		\2 $m \le n \implies (n-m+1) \in \Theta(n)$
+		\2 Tehát $MT \in \Theta(n*m)$ és $mT \in \Theta(n)$ \;\;(mint legfelül)
+		\2 Ha $m$ nem elhanyagolható $n$-hez képest ($m \ge \epsilon * n$ ahol $0 < \epsilon < 1$)\\
+		akkor $(n*m) \in \Theta(n^2) \implies MT \in \Theta(n^2)$
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.95\linewidth]{BruteForce}
+\end{figure}
+
+\pagebreak
+
+\section{Quicksearch}
+
+\begin{outline}
+	\1 Egynél nagyobb lépésekben növeli az $s$ eltolását (de nem ugrik át egy érvényes eltolást sem)
+	\1 Előkészítő fázis: Ábécé minden $\sigma$ eleméhez $shift(\sigma) \in 1..m+1$ címke
+		\2 Csak a mintától függ, a szövegtől nem
+	\1 $shift(\sigma)$ működése:
+		\2 $\sigma$ mindig a minta utáni első karakter a szövegben: $\sigma = T[s+m+1]$
+		\2 Megmondja $T[s+1..s+m]$ megnézése után mennyivel nőjön $s$
+		\2 Ha $\sigma \in P$: $s$ mennyivel nőjön, hogy a minta illeszkedhessen a $T[s+m+1]$ karakterre (pl. ha $P[m]=\sigma$ akkor $shift(\sigma)=1$)
+		\2 Ha $\sigma \notin P$: minta átugorja $T[s+m+1]$ karaktert ($shift(\sigma) = m+1$)
+	\1 Időkomplexitás:
+		\2 $mT \in \Theta(\frac{n}{m+1}+m)$ (pl. $T$ és $P$ diszjunktak)
+			\3 Jobb, mint a brute force megoldás
+		\2 $MT \in \Theta((n-m+2)*m)$ (pl. $T$ és $P$ mind azonos $\sigma$ sokszor)
+			\3 Azonos brute force-szal, de gyakorlatban lassabb
+		\2 Átlagosan gyorsabb, mint a brute force, de azért nem optimális
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=1\linewidth]{QuickSearch}
+\end{figure}
+
+\pagebreak
+
+\subsection{Quicksearch példa}
+
+\begin{outline}
+	\1 Bal fenti ábra:
+		\2 $xxxx$ jelöli a mintával az eltolás előtt összehasonlított szövegrészt
+		\2 Az eltolás mértékét mutatja be: az eltolás utána állapot látható
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=1\linewidth]{QuickSearch-példa-shift}
+\end{figure}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=1\linewidth]{QuickSearch-példa-táblázat}
+\end{figure}
+
+\pagebreak
+
+\section{Knuth-Morris-Pratt (lineáris) algoritmus RÖVIDEN}
+
+\begin{outline}
+	\1 Lineáris időben végzi el a feladatot
+	\1 Nem kell minden esetben a minta elejétől kezdeni az illesztést:\\
+	a prefixet nem kell újra vizsgálni, ha az egyezik a szufixszel
+	\1 Előfeldogozás: ($\Theta(m)$ idő alatt végbemegy)
+		\2 megadunk egy $next$ függvényt, ami megadja a leghosszabb megegyező prefix-szuffix párok hosszát minden minta kezdőszeletre (hosszra)
+		\2 $next(j)$ a leghosszabb olyan $P$ prefix hossza, amely $P$ első $j$ karakterének szuffixe (de nem egyezik meg vele), azaz $next(j) \in 0..(j-1)$
+	\1 A szövegben nem kell visszaugrani, azaz buffer nélkül is használható.
+	(Minden karaktert csak egyszer olvasunk ki, és csak "előrefelé" haladunk.)
+	\1 A mintát sikeres/sikertelen illesztés esetén annyival toljuk előrebb,
+	amerkkora a sikeresen illesztet részminta hossza MÍNUSZ
+	a sikeresen illesztet részminta legnagyobb szuffixe, ami egyben prefix.\\
+	Azaz ez a legnagyobb szuffix lesz a minta kezdete.
+	\1 Időkomplexitás: $MT = mT \in \Theta(n)$
+		\2 $\Omega(n)$, mert $i$ egyesével nő és $n$-ig megy
+		\2 $O(n)$, $2i-j$ értéke mindig szig. mon. nő, tehát max $2n$ iteráció
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=1\linewidth]{KMP}
+\end{figure}
+
+\begin{outline}
+	\1 $next[1]=0$
+	\1 $next[i+1] \le next[i]+1$
+	\1 $next(j) \in 0..(j-1) \;\; (j \in 1..m)$
+\end{outline}
+
+\pagebreak
+
+\begin{outline}
+	\1 $init$ ciklusának invariánsa:
+		\2 $i \le j \le m$
+		\2 $P$ első $i$ karaktere szuffixe $P$ első $j$ karakterének
+		\2 és $\forall l \in (i+2)..j:$ $P$ első $l$ karaktere nem szuffixe $P$ első $j+1$ karakterének, de egyenlőek lehetnek
+		\2 és $next[1..j] = next(1..j)$ (azaz a tömb a fv alapján van töltve)
+	\1 $KMP$ ciklusának invariánsa:
+		\2 $i \in 0..n$ és $j \in 0..(m-1)$ és $j \le i$
+		\2 és $S = \{ s \in 0..(i-m) \;|\; T[(s+1)..(s+m)] = P \}$
+		\2 és $P$ első $j$ karaktere szuffixe $T$ első i karakterének (vagy egyenlőek)
+		\2 és $\forall l \in (j+2)..m:$ $P$ első $l$ karaktere nem szuffixe $T$ első $i+1$ karakterének (és nem is egyenlőek)
+\end{outline}
+
+\subsection{Példa}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=1\linewidth]{KMP-példa-init}
+\end{figure}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=1\linewidth]{KMP-példa-kmp}
+\end{figure}
+
+\pagebreak
+
+\section{Knuth-Morris-Pratt (lineáris) algoritmus}
+
+\subsection{Jelölések}
+
+\begin{outline}
+	\1 Akár teljes prefix: $x \sqsubseteq y \Leftrightarrow \exists z: x + z = y$
+	\1 Igazi prefix: $x \sqsubset y \Leftrightarrow x \sqsubseteq y \wedge x \ne y$
+	\1 Akár teljes szuffix: $x \sqsupseteq y \Leftrightarrow \exists z: z + x = y$
+	\1 Igazi szuffix: $x \sqsupset y \Leftrightarrow x \sqsupseteq y \wedge x \ne y$
+	\1 Az üres sztring mindennek a prefixe és a szuffixe is.
+	\1 Kezdőszelet: $A_j = A[1..j]$ (ezt a jelölést ritkán használjuk)
+		\2 $A_0$ az üres sztring
+	\1 Prefix-szuffix: $x \square y \leftrightarrow x \sqsubset y \wedge x \sqsupset y$
+	\1 $i.$ legnagyobb elem: $\max_i H$ \;\; ($i \in 1..|H|$)
+		\2 $\max_1 H = \max H$ és $\max_{|H|} H = \min H$
+	\1 $H(j) = \{h \in 0..j-1 \;|\; P_h \sqsupset P_j\} = \{|x| \;|\; x \square P_j\}$
+	\;\; ($j \in 1..m$) \\
+	Azaz azon sztring hosszak, amelyek prefixek és szuffixek is $P$-nek egyben.
+	\1 $next(j) = \max H(j)$ \;\; ($j \in 1..m$)\\
+	Leghosszab $P$-beli prefix hossza, ami egyben valódi szuffixe $P_j$-nek.
+\end{outline}
+
+NINCS BEFEJEZVE, NAGYON HIÁNYOS
+
+\end{document}
diff --git "a/algo2/t\303\266m\303\266r\303\255t\303\251s/algo2-t\303\266m\303\266r\303\255t\303\251s.pdf" "b/algo2/t\303\266m\303\266r\303\255t\303\251s/algo2-t\303\266m\303\266r\303\255t\303\251s.pdf"
new file mode 100644
index 0000000..2801d30
Binary files /dev/null and "b/algo2/t\303\266m\303\266r\303\255t\303\251s/algo2-t\303\266m\303\266r\303\255t\303\251s.pdf" differ
diff --git "a/algo2/t\303\266m\303\266r\303\255t\303\251s/algo2-t\303\266m\303\266r\303\255t\303\251s.tex" "b/algo2/t\303\266m\303\266r\303\255t\303\251s/algo2-t\303\266m\303\266r\303\255t\303\251s.tex"
new file mode 100644
index 0000000..d9c91e9
--- /dev/null
+++ "b/algo2/t\303\266m\303\266r\303\255t\303\251s/algo2-t\303\266m\303\266r\303\255t\303\251s.tex"
@@ -0,0 +1,257 @@
+% !TeX spellcheck = hu_HU
+\documentclass[12pt,a4paper]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{cmap}
+\usepackage[T1]{fontenc}
+\usepackage[magyar]{babel}
+\usepackage{amsmath}
+\usepackage{amsfonts}
+\usepackage{amssymb}
+\usepackage{graphicx}
+
+\usepackage{struktex}
+\usepackage{outlines}
+\usepackage{hyperref}
+
+\hyphenpenalty=10000
+
+\begin{document}
+
+\begin{center}
+	\huge
+	Algoritmusok és adatszerkezetek II\\
+	\vspace{1mm}
+	\LARGE
+	Tömörítés témakör jegyzete\\
+	\vspace{5mm}
+	\large
+	Készült Ásványi Tibor előadásai és gyakorlatai alapján\\
+	\vspace{5mm}
+	Sárközi Gergő, 2021-22-1. félév\\
+	Nincsen lektorálva!
+\end{center}
+
+\tableofcontents
+
+\pagebreak
+
+\section{Tömörítés}
+
+\begin{outline}
+	\1 csak veszteségmentessel foglalkozunk
+	\1 kód = kódszavak nemüres halmaza (kódfával ábrázolható)
+	\1 betűnkénti kódolás: adatot betűnként
+	$ \sum \to \mathbb{C} \subset \mathbb{T}^* $
+	bijektív (kölcsönösen egyértelmű) leképezéssel készítjük
+		\2 $ \sum $ = ábécé, karakterek halmaza
+		\2 $ \mathbb{C} $ = kód
+		\2 $ T=\{0,1\} $ általában
+		\2 továbbiakban legyen $ r=|\mathbb{T}| $ és $ d=|\sum| $
+\end{outline}
+
+\pagebreak
+
+\section{Naiv módszer}
+
+\begin{outline}
+	\1 egyenletes kód: kód szavainak hossza egyenlő
+	\1 egy karakter (min) $ \lceil log_r d \rceil $ hosszan kódolható
+	\1 kódtáblázat: karakter-kód párok
+	\1 kódtáblázatot is csatolni kell az adattal
+	(és így mérni a tömörítés effektivitását)
+\end{outline}
+
+\subsection{Példa}
+
+Bemenet: ERRE\_ARRA\_MERRE\_ARRA \\
+$ \sum = \{ E, R, \_, A, M \} \implies d=5 $  \\
+$ l=\lceil log_2 5 \rceil=3 $ \\
+Kimenet hossza: 20x3=60 + kódtáblázat
+
+\begin{table}[h!]
+	\begin{tabular}{|c|c|}
+		\hline
+		\textbf{Betű} & \textbf{Kód} \\
+		\hline
+		E & 000 \\
+		\hline
+		R & 001 \\
+		\hline
+		\_ & 010 \\
+		\hline
+		A & 011 \\
+		\hline
+		M & 100 \\
+		\hline
+	\end{tabular}
+\end{table}
+
+\pagebreak
+
+\section{Huffmann-kód}
+
+\begin{outline}
+	\1 betűnkénti optimális kódolás
+	\1 2 hiba: 2x kell beolvasni és betűnkénti kódolás (ami pl. képeknél nem nagyon tud tömöríteni)
+	\1 nem egyértelmű: azonos gyakoriságú betűk (és 0-1) felcserélhetők
+	\1 prefix-kód: kódszavak halmaza prefix mentes
+	\1 kódtáblázatot is csatolni kell az adattal
+	\1 kódfa: szigorúan bináris fa: 2d-1 csúcs
+\end{outline}
+
+\subsection{Példa}
+
+Bemenet: ERRE\_ARRA\_MERRE\_ARRA
+
+\begin{figure}[h]
+	\begin{minipage}{.5\textwidth}
+		\begin{tabular}{|c|c|}
+			\hline
+			\textbf{Betű} & \textbf{Gyakoriság} \\
+			\hline
+			E & 4 \\
+			\hline
+			R & 8 \\
+			\hline
+			\_ & 3 \\
+			\hline
+			A & 4 \\
+			\hline
+			M & 1 \\
+			\hline
+		\end{tabular}
+	\end{minipage}
+	\begin{minipage}{.5\textwidth}
+		\begin{tabular}{|c|}
+			\hline
+			\textbf{minPrQueue} \\
+			\hline
+			<(1,M),(3,\_),(4,A),(4,E),(8,R)> \\
+			\hline
+			<(4,M\_),(4,A),(4,E),(8,R)> \\
+			\hline
+			<(4,E),(8,R),(8,M\_A)> \\
+			\hline
+			<(8,M\_A),(12,ER)> \\
+			\hline
+			<(20,M\_AER)> \\
+			\hline
+		\end{tabular}
+	\end{minipage}
+\end{figure}
+
+\begin{outline}
+	\1 amíg a sorban van $\ge2$ elem
+	\2 szedjük ki őket, készítsünk egy szülő node-ot nekik (bal/jobb oldalt kapja egy gyerek a gyakorisága alapján)
+	\2 rakjuk be a szülő node-ot a gyerekek értékének összértékével
+	\1 kész a fa
+\end{outline}
+
+\includegraphics[width=0.7\linewidth]{huffman-code-tree}
+
+TODO stuki (kóddal együtt - kóddal tesztelve)
+
+\pagebreak
+
+\section{Lempel-Ziv-Welch (LZW) módszer}
+
+\begin{outline}
+	\1 nem betűnkénti kódolás: szótárkód
+		\2 nincs meg az a hatékonysági határ, mint Huffmann kódnál
+	\1 lépésről lépésre egy $S$ kódtáblát (szótárat) bővít
+	\1 szótár tulajdonságai:
+		\2 egybetűs szavak alapból szerepelnek benne
+		\2 ha egy szó benne van a szótárban, akkor minden kezdődarabja is benne van
+		\2 minden tárolt szónak ($x \in S$) fix hosszúságú kódja van ($c(x)$)
+	\1 csak egyszer olvassuk be az adatot: egy időben kódolunk és építünk szótárat
+	\1 kódtáblát nem kell csatolni a kódolt adathoz
+	\1 kódolás: ha $x \in S$ szót találunk és a következő betű, $Y$, már $\notin S$,
+	akkor $c(x)$-et kiírjuk, $xY$ szót felvesszük a $S$ szótárba. $c(xY)$ a legkisebb szabad kód.
+	A beolvasást az $Y$ betűvel folytatjuk.
+	\1 $c(x)$ fix hosszú, méghozzá ez a hossz egy előre ismert konstans (általában 12 bit)
+	\1 a kódolt adat mellé nem szükséges a szótár csatolása
+	\1 hibák:
+		\2 hosszú szöveg esetén túl sok új kód van bevezetve, ami lassít
+		\2 ezért korlátozhatjuk a kódszavak számát, hosszát
+		\2 vagy csak a bemenet egy kezdőszeletén építjük a szótárat, utána már csak használjuk
+	\1 Kódot egyből felhasználjuk miután berakjuk szótárba:
+	nem probléma, így is ki tudjuk találni a kód utolsó karakterét: azonos az elsővel
+\end{outline}
+
+\pagebreak
+
+\subsection{Példa}
+
+\begin{figure}[h]
+	\begin{minipage}{.5\textwidth}
+		\begin{tabular}{|c|c|c|c|}
+			\hline
+			\multicolumn{4}{|c|}{Bemenet: BBCABCABABAAC} \\
+			\hline
+			Ki  & Akt. & Köv. & Új \\
+			kód & szó & szó & kód \\
+			\hline
+			2 & B & B & 4 \\
+			\hline
+			2 & B & C & 5 \\
+			\hline
+			3 & C & A & 6 \\
+			\hline
+			1 & A & B & 7 \\
+			\hline
+			5 & BC & A & 8 \\
+			\hline
+			7 & AB & A & 9 \\
+			\hline
+			9 & ABA & A & 10 \\
+			\hline
+			1 & A & C & 11 \\
+			\hline
+			3 & C & - & - \\
+			\hline
+		\end{tabular}
+		\caption{Kódolás példa}
+	\end{minipage}
+	\begin{minipage}{.5\textwidth}
+		\begin{tabular}{|c|c|c|c|}
+			\hline
+			\multicolumn{4}{|c|}{Bemenet: 2 2 3 1 5 7 9 1 3} \\
+			\hline
+			Be  & Akt. & Köv. & Új \\
+			kód & szó & szó & kód \\
+			\hline
+			2 & B & B & 4 \\
+			\hline
+			2 & B & C & 5 \\
+			\hline
+			3 & C & A & 6 \\
+			\hline
+			1 & A & B & 7 \\
+			\hline
+			5 & BC & A & 8 \\
+			\hline
+			7 & AB & A & 9 \\
+			\hline
+			9 & ABA & ... & 10 \\
+			\hline
+			... & ... & ... & ... \\
+			\hline
+			... & ... & ... & ... \\
+			\hline
+		\end{tabular}
+		\caption{Dekódolás példa}
+	\end{minipage}
+\end{figure}
+
+\pagebreak
+
+\subsection{Stuki}
+
+\begin{outline}
+	\1 Ha a kódok $b$ bitesek, akkor $MAXCODE = 2^b-1$
+	\1 Item: szó-kód pár ($string:\sum <>$ és $code:\mathbb{N}$ pár)
+\end{outline}
+
+\includegraphics[width=0.8\linewidth]{lzw}
+
+\end{document}
diff --git "a/algo2/t\303\266m\303\266r\303\255t\303\251s/huffman-code-tree.png" "b/algo2/t\303\266m\303\266r\303\255t\303\251s/huffman-code-tree.png"
new file mode 100644
index 0000000..18c8018
Binary files /dev/null and "b/algo2/t\303\266m\303\266r\303\255t\303\251s/huffman-code-tree.png" differ
diff --git "a/algo2/t\303\266m\303\266r\303\255t\303\251s/lzw.jpg" "b/algo2/t\303\266m\303\266r\303\255t\303\251s/lzw.jpg"
new file mode 100644
index 0000000..534cd74
Binary files /dev/null and "b/algo2/t\303\266m\303\266r\303\255t\303\251s/lzw.jpg" differ
diff --git a/dimat2/README.md b/dimat2/README.md
new file mode 100644
index 0000000..bc09952
--- /dev/null
+++ b/dimat2/README.md
@@ -0,0 +1,9 @@
+**Képzés:** ELTE IK Proginf BSc, Szoftvertervező (B) szakirány (kezdés éve: 2020)  
+**Tárgy neve:** Diszkrét matematika II  
+**Tárgy kódja:** IP-18bDM2E/G
+
+A jegyzet témakörönként külön-külön fájlra van bontva.
+
+Linkek:
+ - [Polinom jegyzet link](polinom/dimat2-polinom.pdf)
+ - [Számelmélet jegyzet link](számelmélet/dimat2-számelmélet.pdf)
diff --git a/dimat2/polinom/dimat2-polinom.pdf b/dimat2/polinom/dimat2-polinom.pdf
new file mode 100644
index 0000000..a2de67e
Binary files /dev/null and b/dimat2/polinom/dimat2-polinom.pdf differ
diff --git a/dimat2/polinom/dimat2-polinom.tex b/dimat2/polinom/dimat2-polinom.tex
new file mode 100644
index 0000000..7e2e673
--- /dev/null
+++ b/dimat2/polinom/dimat2-polinom.tex
@@ -0,0 +1,606 @@
+% !TeX spellcheck = hu_HU
+\documentclass[12pt,a4paper]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{cmap}
+\usepackage[T1]{fontenc}
+\usepackage[magyar]{babel}
+\usepackage{amsmath}
+\usepackage{amsfonts}
+\usepackage{amssymb}
+\usepackage{graphicx}
+
+\usepackage{outlines}
+\usepackage{hyperref}
+
+\hyphenpenalty=10000
+
+\begin{document}
+
+\begin{center}
+	\huge
+	Diszkrét matematika II\\
+	\vspace{1mm}
+	\LARGE
+	Polinomok témakör jegyzete\\
+	\vspace{5mm}
+	\large
+	Készült Burcsi Péter előadásai\\
+	és Harrison-Juhász Zsófia gyakorlatai alapján\\
+	\vspace{5mm}
+	Sárközi Gergő, 2021-22-1. félév\\
+	Nincsen lektorálva!
+\end{center}
+
+\tableofcontents
+
+\pagebreak
+
+\section{Gyűrű, Test, integritási tartomány}
+
+\subsection{Gyűrű ($R,+,*$)}
+
+\begin{outline}
+	\1 Példa: $\mathbb{Z}$, $\mathbb{Q}$, $\mathbb{R}$, $\mathbb{C}$, $\mathbb{Z}_m$ (mod m maradékosztályok gyűrűje)
+	\1 $+$: R-en művelet
+		\2 asszociatív, kommutatív
+		\2 létezik nullelem: 0 ($a+0=0+a=a$)
+		\2 minden elemnek van inverze ($a-a=0$)
+	\1 $*$: R-en művelet
+		\2 asszociatív
+		\2 nem feltétlenül kommutatív (pl. mátrixok miatt: ott nem azok)
+	\1 $*,+$: $*$ disztributív $+$-ra: $x*(y+z)=x*y+x*z$
+\end{outline}
+
+\subsection{Integritási tartomány}
+
+\begin{outline}
+	\1 Példa: $\mathbb{Z}$, $\mathbb{Q}$, $\mathbb{R}$, $\mathbb{C}$, $\mathbb{Z}_p$ ahol p egy prím
+	\1 Egy R gyűrű integritási tartomány, ha:
+		\2 legalább 2 eleme van
+		\2 szorzás kommutatív
+		\2 gyűrű (szorzás) nullosztómentes ($a*b=0 \implies a=0 \lor b=0$)
+			\3 ellenpélda: $\mathbb{Z}_{10}$: $6*5=0$
+\end{outline}
+
+\subsection{Egységelemes Integritási Tartomány (EIT)}
+
+\begin{outline}
+	\1 Integritási tartomány, ahol létezik $1 \in R$: $a*1=1*a=a$
+	\1 Van $+,*,-$: ahogy megszoktuk, pl.: $ax=ay \implies a=0 \lor x=y$
+\end{outline}
+
+\subsection{Test}
+
+\begin{outline}
+	\1 Gyakorlatilag: egy E.I.T. ahol van osztás
+	\1 $\forall a \in R: a \ne 0 \implies \exists a^{-1}: a*a^{-1}=1$
+	\1 pl.: $\mathbb{Q}$, $\mathbb{R}$, $\mathbb{Z}_p$ ahol $p$ prím
+	\1 Minden $f$ polinom elosztható maradékosan bármely $g \ne 0$ polinommal
+\end{outline}
+
+\pagebreak
+
+\section{Polinom}
+
+\begin{outline}
+	\1 Egy R gyűrű feletti polinomokon olyan $(f_0,f_1,f_2,...)$ végtelen sorozatokat értünk,
+	ahol $f_j \in R$ és $\exists n \in \mathbb{N}: j>n \implies f_j=0$
+	\1 Példa: $6+5x+2x^2+3x^4$ $\to$ $(6,5,2,0,3,0,0,0,...)$
+	\1 R feletti polinomok halmaza: $R[x]$ (x: polinomok határozatlanja)
+		\2 Ha R E.I.T., akkor $R[x]$ is E.I.T.
+	\1 Polinomfüggvény: $f \in R \to R$, $f(r)=f_0+f_1*r+...+f_{deg(f)}*r^{deg(f)}$
+\end{outline}
+
+\subsection{Polinom foka}
+
+\begin{outline}
+	\1 polinom foka ($\deg f$): legnagyobb $n$ amelyre $f_n \ne 0$
+		\2 a fok $-\infty$, ha $f=(0,0,0,...)$
+	\1 főegyüttható: $f_n$ ahol $n=\deg f$
+	\1 konstans tag: $f_0$
+	\1 f lineáris, ha $\deg f \le 1$
+	\1 f konstants, ha $\deg f \le 0$
+\end{outline}
+
+\subsection{Összeadás, szorzás $R[x]$-en}
+
+\begin{outline}
+	\1 $f=(f_0,f_1,f_2,...)$ és $g=(g_0,g_1,...)$
+	\1 $f+g=(f_0+g_0,f_1+g_1,...)$
+		\2 $deg (f+g) \le max(deg(f),\; deg(g))$
+	\1 $f*g=h$ ahol: $h_k=\sum_{i+j=k}f_i*g_j$
+		\2 Példa: $f=(2,0,1,3,0,...)$ és $g=(7,-2,3,0,...)$\\
+		$f*g=(?,2*3+0*-2+1*7,...)=(?,f_0*g_2+f_1*g_1+f_2*g_0,...)$
+		\2 $\deg (f*g) \le \deg(f)+\deg(g)$
+			\3 egyenlő, ha $R$ egy integritási tartomány: $f_{\deg(f)}*g_{\deg(g)} \ne 0$
+\end{outline}
+
+\subsection{Maradékos osztás tétele}
+
+\begin{outline}
+	\1 Legyen $R$ egy E.I.T. és $f,g \in R[x]$ és $n=\deg f$ és $m = \deg g$
+	\1 Ha $\exists {g_m}^{-1}$ (van reciproka a főegyütthatónak)
+	\1 Akkor $\exists! g,r \in R[x]: f = g*q+r \wedge \deg r < \deg g$
+	\1 Egyértelműség bizonyítása:
+		\2 Legyen $f=g*q_1+r_1=g*q_2+r_2$
+		\2 Ebből következik: $g*(q_1-q_2)=r_2-r_1$
+		\2 Fokokra áttérve: $\deg g + \deg (q_1 - q_2) = \deg (r_2 - r_1)$
+		\2 Ha $q_1 \ne q_2$: a bal oldal $\ge \deg g$, a jobb oldal $< \deg g$
+		\2 Tehát $(q_1 = q_2) \implies (g*0=0) \implies (r_r - r_2 = 0)$
+	\1 Létezés bizonyítása:
+		\2 $q = f_n*g_m^{-1}*x^{n-m}+q^*$ \;\; (ahol $q^*$ ugyan ez $f^*$-gal)
+		\2 $f^*=f-g*f_n*g_m^{-1}*x^{n-m} = g*q^*+r^*$
+		\2 Rekurzió alapesete: ha $\deg f < \deg g$ akkor $q=0$ és $r=f$
+		\2 $f$ fokszáma csökken, $\deg f^* < \deg f$ belátása:\\
+		$f^*_n=f_n*x^n-g*f_n*g_m^{-1}*x^{n-m} = f_n*x^n-f_n*x^n = 0$
+\end{outline}
+
+\subsection{Polinom osztás a gyakorlatban}
+
+\subsubsection{Bizonyításhoz hasonlóan, rekurzívan}
+
+\begin{outline}
+	\1 rekurzívan $f$-ből mindig kivonjuk $g*f_n*g_m^{-1}*x^{n-m}$-ot
+	\1 megállunk, ha $\deg f < \deg g$, ekkor $r=f$
+	\1 $q=\sum f_n*g_m^{-1}*x^{n-m}$
+\end{outline}
+
+\subsubsection{Horner táblázat}
+
+\begin{outline}
+	\1 $f = (x-c)*q + r$ ahol $\deg r \le 0$ \;\; (azaz $g=x-c$ és $\deg g = 1$)
+\end{outline}
+
+\begin{table}[h]
+	\centering
+	\begin{tabular}{|c|c|c|c|c|c|c|}
+		\hline
+		& $f_n$ & $f_{n-1}$ & $f_{n-2}$ & ... & $f_0$ & \\
+		\hline
+		c & $\times$ & $c_1=f_n$ & $c_2=c_1*c+f_{n-1}$ & .. & $c_n=c_{n-1}*c+f_1$ & $c_{n+1}=...=f(c)$ \\
+		\hline
+	\end{tabular}
+\end{table}
+
+\pagebreak
+
+\section{Gyöktényező kiemelése, következményei}
+
+\subsection{Gyöktényező kiemelése}
+
+\begin{outline}
+	\1 Ha $R$ egy E.I.T. és $f \in R[x]$ és $f(c)=0$
+	\1 Akkor $\exists q \in R[x]: f = q*(x-c)$
+	\1 Bizonyítás:
+		\2 $f$ osztása $x-c$-vel: $f = q*(x-c)+r$
+		\2 $\deg r < \deg x-c = 1 \implies r$ konstans
+		\2 $c$ gyök $\implies 0=f(c)=q*(c-c)+r \implies r=0$
+\end{outline}
+
+\subsection{Gyökök száma max a polinom fokszáma}
+
+\begin{outline}
+	\1 Legyen $R$ egy E.I.T. (!!!) és $f \in R[x]$ és $\deg f = n$
+	\1 Ekkor $f$-nek max $n$ gyöke van
+	\1 Bizonyítás: (indukcióval)
+		\2 $n=0 \implies f(x)=r \implies $ nincs gyök ha $r \ne 0$
+			\3 ha $r = 0$ akkor $f=0$ azaz $\deg f = -\infty$
+		\2 indukciós lépés: $\exists c$ gyök $\implies f=(x-c)*q$
+			\3 $x-c$ az 1 gyök
+			\3 $\deg q = n-1$, indukciós feltevés alapján max $n-1$ gyöke van
+			\3 $1+$ max $n-1=$ max $n$, tehát készen vagyunk
+\end{outline}
+
+\subsection{Polinomok egyenlősége több behelyettesítés alapján}
+
+\begin{outline}
+	\1 Legyen $R$ egy E.I.T. és legyen $R$-nek legalább $n+1$ eleme (pl. végtelen)
+	\1 Ha $\deg f_1 \le n$ és $\deg f_2 \le n$ és $\forall r \in R: f_1(r) = f_2(r)$
+	\1 Akkor $f_1 = f_2$ (azaz az együtthatók és tehát a fokszámok megegyeznek)
+	\1 Bizonyítás: tegyük fel, hogy $f_1 \ne f_2$
+		\2 $f_1 - f_2 \ne 0$ és $\deg f_1 - f_2 \le n$ $\implies$ max $n$ gyöke van (előző tétel)
+		\2 Tehát $(f_1-f_2)(r)$ nem lehet nulla $n+1$ helyen, azaz ellentmondás
+\end{outline}
+
+\pagebreak
+
+\subsection{Lagrange interpoláció}
+
+\begin{outline}
+	\1 Legyen $R$ egy test és $\deg f \le n$
+	\1 Ha $n+1$ helyen ismerem $f(r)$ értékét: $y_i=f(x_i)$ \;\; ($i=1..n+1$)
+	\1 Akkor $f$ egyértelműen megadható polinomok egyenlősége tétel miatt:\\
+	$\exists! f \in R[x]: \forall i \in [1,n+1]: f(x_i) = y_i$
+	\1 Bizonyítás:
+		\2 Legyen $l_i(x) = (\; \prod_{j=0 \wedge i \ne j}^{n} (x-x_j) \;) \;/\;
+		(\; \prod_{j=0 \wedge i \ne j}^{n} (x_i-x_j) \;)$
+		\2 Ekkor $l_i(x)$ akkor $1$ ha $i=j$ egyébként mindig $0$
+		\2 Így ez megoldás: $f(x) = \sum_{i=0}^{n} y_i*l_i(x)$
+\end{outline}
+
+\section{Többváltozós polinomok}
+
+\begin{outline}
+	\1 pl.: $4x^2+3xy+2y+1$
+	\1 $R[x_1,x_2,...,x_n] = R[x_1][x_2]...[x_n]$ 
+\end{outline}
+
+\section{Egység (más fogalom, mint az egységelem)}
+
+\begin{outline}
+	\1 Egy együttható egység, ha $R$ minden elemének osztója.
+		\2 Ekvivalens megfogalmazás: egység, ha létezik multiplikatív inverze
+	\1 Egy polinom egység, ha minden polinomnak az osztója.
+		\2 Test feletti polinomgyűrű: pontosan a nemnulla konstans polinomok.
+	\1 Gyűrűelemet egységgel szorozva annak osztói, többszörösei nem változnak.
+	\1 Egy EIT két elemét asszociáltaknak nevezzük, ha egymás egységszeresei.
+		\2 Ez egy ekvivalencia (reflexív, szimmetrikus, tranzitív) reláció.
+\end{outline}
+
+\pagebreak
+
+\section{Felbonthatatlan (irreducibilis) polinomok}
+
+\begin{outline}
+	\1 $f \in R[x]$ irreducibilis, ha:
+		\2 $f \ne 0$ és $f$ nem egység
+		\2 $f=g*h \implies$ $g$ egység vagy $h$ egység
+	\1 Példa irreducibilis-ra $\mathbb{Q}$-ban: $(x^2+1)=\frac{1}{2}*(2x^2+2)$ \;\; ($\frac{1}{2}$ egység)
+	\1 Példa nem irreducibilis-ra: $(x^2-1)=(x-1)(x+1)$
+	\1 Test felett minden elsőfokú polinom felbonthatatlan.
+\end{outline}
+
+\subsection{Algebra alaptétele $\mathbb{C}$-ben}
+
+\begin{outline}
+	\1 Ha $f \in \mathbb{C}[x]$ és $\deg f \ge 1$ akkor létezik $f$-nek gyöke
+	\1 Nem bizonyítjuk, nagyon nehéz
+	\1 Következmény: $\mathbb{C}$-ben irreducibilis $\Leftrightarrow$ elsőfokú polinom
+\end{outline}
+
+\subsection{Irreducibilis $\mathbb{R}$-ben}
+
+\begin{outline}
+	\1 $\mathbb{R}$-ben azok és csak azok az $f$ polinomok irreducibilisak, amik:
+		\2 $\deg f = 1$
+		\2 $\deg f = 2$ és $f=ax^2+bx+c$ és $b^2-4ac < 0$
+\end{outline}
+
+\subsection{Irreducibilis $\mathbb{Z}_p$-ben, $\mathbb{Q}$-ban, $\mathbb{Z}$-ben}
+
+\begin{outline}
+	\1 Tétel bizonyítás nélkül
+	\1 Minden $n \ge 1$-re létezik $n$-ed fokú irreducibilis polinom
+\end{outline}
+
+\subsection{Felbonthatóság és gyökök kapcsolata test felett}
+
+\begin{outline}
+	\1 van gyöke $\Leftrightarrow$ létezik első fokú faktora (osztója)
+	\1 $\deg f \ge 2$ és van gyöke $\implies$ felbontható
+	\1 $\deg f = 2 \lor \deg f = 3$: felbontható $\Leftrightarrow$ van gyöke
+\end{outline}
+
+\pagebreak
+
+\section{Modulo polinom}
+
+\begin{outline}
+	\1 Létezik ilyen
+	\1 Elvégzem a műveletet, elosztom a modulo-val és a maradékot veszem
+	\1 Ha $f$ irreducibilis, akkor $mod \; f$ egy test
+	\1 $\mathbb{C}$: mintha $mod \; i^2+1$-ben számolnánk
+	\1 Euklideszi algoritmussal megoldható pl. $(3+2x)*g \equiv 1 \mod x^2+1$\\
+	$(3+2x)^{-1} \equiv \frac{4}{13} * (-\frac{1}{2}x + \frac{3}{4}) \mod x^2+1$
+\end{outline}
+
+\subsection{Véges testek}
+
+\begin{outline}
+	\1 Alkalmazás: kódolás, hibajavítás
+	\1 Véges test: egyszerre $mod\;p$ ($p$ prím) és $mod\;f$ ($\deg f = n$)
+	\1 Ekkor $p^n$ elemű (elemszámú) testről beszélünk
+	\1 pl.: $(2x+1)(x+2) \equiv 2x \;\; (mod \; 3, \; mod \; x^2+1)$\\
+		$3^2=9$ elem: $\{0,1,2,x,x+1,x+2,2x,2x+1,2x+2\}$
+\end{outline}
+
+\section{Elem rendje, gyűrű karakterisztikája}
+
+\subsection{Elem additív rendje}
+
+\begin{outline}
+	\1 Legyen $R$ egy gyűrű és $0 \ne r \in R$
+	\1 $r$ rendje a legkisebb olyan $n$ egész, amelyre $n*r=0$
+	\1 pl.: $Z_7$-ben $3$ rendje $7$ mert $7*3=21 \; mod \; 7 = 0$
+	\1 Nullosztómentes gyűrűben az összes nemnulla elem rendje megegyezik.
+\end{outline}
+
+\subsection{Gyűrű karakterisztikája}
+
+\begin{outline}
+	\1 $char(R)$: nullosztómentes $R$ gyűrű karakterisztikája
+		\2 $char(R)=0$ ha $R$ elemeinek közös rendje nem véges
+		\2 egyébként $char(R)=$ $R$ elemeinek közös additív rendje
+	\1 Példa: $char(\mathbb{Z}_p) = p$ ha $p$ prím
+	\1 Példa: $char(\mathbb{Z})=char(\mathbb{Q})=char(\mathbb{R})=char(\mathbb{C})=0$
+\end{outline}
+
+\pagebreak
+
+\section{Algebrai derivált}
+
+\begin{outline}
+	\1 Legyen $f \in R[x]$ ahol $R$ test és $f=a_0+a_1x+a_2x^2+...+a_nx^n$
+	\1 Ekkor az algebrai derivált: $f'=a_1+2a_2x+3a_3x^2+...+n*a_nx^{n-1}$
+		\2 $f'=\sum_{k=0}^{n} k*f_k*x^{k-1}$
+\end{outline}
+
+\section{Gyökök multiplicitása}
+
+\begin{outline}
+	\1 $c$ min. $k$-szoros gyök: $\exists q: f=(x-c)^k*q$
+	\1 $c$ pontosan $k$-szoros gyök: $c$ $k$-szoros gyök, de nem $k+1$-szeres
+\end{outline}
+
+\subsection{Algebrai deriválttal összefüggés}
+
+\begin{outline}
+	\1 $f$-nek a $c$ $k$-szoros gyöke $\implies$ $f'$-nek $c$ min. $(k-1)$-szeres gyöke
+	\1 Bizonyítás:
+		\2 $f=(x-c)^k*q$
+		\2 $f'=((x-c)^k*q)'=$nem biz$=((x-c)^k)'*q+(x-c)^k*q'=$\\
+		$=k*(x-c)^{k-1}*q+(x-c)^k*q'=(x-c)^{k-1}*(k*q+(x-c)*q')$
+	\1 Ez a tétel "min" helyett "pontosan"-nal akkor működik, ha $char(R) \not |\; k$
+		\2 pl. $\mathbb{R}$ esetén, mivel $char(\mathbb{R})=0 \not |\; k$ (minden $k \ne 0$)
+\end{outline}
+
+\subsection{LNKO-val, algebrai deriválttal összefüggés}
+
+\begin{outline}
+	\1 $LNKO(f,f')=d=1 \implies$ $f$-nek nincs többszörös gyöke
+	\1 $char(R)=0 \implies$ $d$ gyökei $f$ legalább kétszeres gyökei
+\end{outline}
+
+\subsection{Számolása Horner táblázattal}
+
+\begin{outline}
+	\1 Egy Horner táblázatot újrahasználhatunk
+		\2 Mindig kevesebb oszlop kell, ezért mindig eggyel több $\times$-ot rakunk
+		\2 Minden (pl. a maradék) azonos oszlopban van
+	\1 Az előző eredmény mindig az új osztandó polinom
+	\1 Addig írunk új sort, amíg a maradék $0$
+\end{outline}
+
+\pagebreak
+
+\section{Euklideszi algoritmus polinomokkal}
+
+\begin{outline}
+	\1 Legyen $R$ egy test és $f,g \in R[x]$
+	\1 Ha $d=LNKO(f,g)$ akkor
+		\2 $d|f$ és $d|g$ \;\; ($d$ közös osztó)
+		\2 $\forall h: (h|f) \wedge (h|g) \implies h|d$ \;\; ($d$ a legnagyobb)
+	\1 A legnagyobb közös osztó egészek körében sem volt egyértelmű ($x$, $-x$)
+	és polinomok esetén sem az.
+	\1 Bővített euklideszi algoritmus is jó: $LNKO(f,g)=d=f*u+g*v$
+\end{outline}
+
+\subsection{Euklideszi algoritmus a gyakorlatban}
+
+\begin{outline}
+	\1 Egységgel be szabad szorozni, az nem változtat az eredményen.
+	\1 Egymást követő osztások:
+		\2 $f,g,r_1,r_2,...$ kettesével osztása megadja a következőt
+		\2 1.: $f/g \implies f=g*q_1+r_1$
+		\2 2.: $g/r_1 \implies g=r_1*q_2+r_2$
+		\2 3.: $r_1/r_2 \implies r_1=r_2*q_3+r_3$
+	\1 Addig osztunk, amíg a maradék 0 nem lesz.\\
+	Ekkor az utolsó $\ne 0$ maradék a megoldás (LNKO).
+		\2 pl.: $r_2 \ne 0 \wedge r_3 = 0 \implies LNKO(f,g)=d=r_2$
+	\1 Bővített euklideszi algoritmus: pontosan úgy, mint skalárokkal
+\end{outline}
+
+\subsection{Kétváltozós diofantikus egyenletek}
+
+\begin{outline}
+	\1 Legyen $f*u+g*v=h$
+	\1 Bővített euklideszivel ki kell számolni: $f*u'+g*v'=d=gcd(f,g)$
+		\2 Itt is pontosan akkor oldható meg, ha $d|h$
+	\1 Megoldások, ahol $w \in R[x]$ egy tetszőleges polinom:
+		\2 $u_w = u_0+\frac{g}{d}w$ ahol $u_0=u'*\frac{h}{d}$
+		\2 $v_w = v_0-\frac{f}{d}w$ ahol $v_0=v'*\frac{h}{d}$
+\end{outline}
+
+\pagebreak
+
+\section{Hibakorlátozó kódolás}
+
+\subsection{Alapfogalmak}
+
+\begin{outline}
+	\1 $\Sigma$ az ábécé, azaz egy rögzített véges halmaz
+		\2 $n$ hosszú szavak halmaza: $\Sigma^n$
+	\1 Hamming-távolság $2$ $n$ hosszú szó között: pozíciók száma, ahol különböznek
+		\2 Szóhalmaz távolsága: min\{ bármely $2$ szavának távolsága \}
+	\1 Kód: $\Sigma^n$ részhalmaza (azaz bizonyos $n$ hosszú szavak)
+		\2 Kódszó: kód egy eleme
+	\1 Szándék: küldeni kívánt szó (ezt alakítjuk kódszóvá)
+	\1 Dekódolás: üzenethez legközelebbi kódszó kiválasztása
+\end{outline}
+
+\subsection{t-hibajelző, t-hibajavító kód}
+
+\begin{outline}
+	\1 t-hibajelző kód: max t helyen sérült üzenetnél észreveszi, hogy sérült
+		\2 $d$ távolságú kód $\implies$ $d-1$ hibát jelez
+		\2 Bizonyítás: távolság $d$ $\implies$ $d-1$ változás nem adhat új kódszót
+	\1 t-hibajavító kód: max t helyen sérül üzenetnek tudja az eredeti kódszavát
+		\2 $d$ távolságú kód $\implies$ $\lfloor \frac{d-1}{2} \rfloor$ hibát javít
+		\2 Bizonyítás:
+			\3 Legyen $w$ az eredeti kódszó, $w'$ a sérült, $w_2$ egy másik kódszó
+			\3 Kiindulás: $distance(w,w') \le \lfloor \frac{d-1}{2} \rfloor$
+			\3 Legyen $distance(w',w_2)=x$
+			\3 Be kell látni: $\lfloor \frac{d-1}{2} \rfloor < x$
+			\3 $distance(w,w_2) \ge d \implies x + \lfloor \frac{d-1}{2} \rfloor \ge d$
+			\3 Átrendezve: $x \ge \lfloor \frac{d+1}{2} \rfloor > \lfloor \frac{d-1}{2} \rfloor$
+	\1 Példa béna, pazarló kódra: n-szeres ismétlés $\implies$ kód távolsága n
+\end{outline}
+
+\pagebreak
+
+\subsection{Singleton-korlát}
+
+\subsubsection{Tétel}
+
+\begin{outline}
+	\1 Legyen
+		\2 $Q=|\Sigma|$ az abécé mérete
+		\2 $c$ a kódszavak száma
+		\2 $n$ a kódszavak hossza
+		\2 $d$ a kód távolsága
+	\1 Állítás: $c \le Q^{n-d+1} = Q^{n-(d-1)}$
+	\1 Bizonyítás
+		\2 A kód távolsága $d$ $\implies$ $d-1$ változtatás nem adhat új kódszót
+		\2 Változtassuk az összes kódban az utolsó $d-1$ betűt ugyan arra
+		\2 Így is páronként különböznek, szóval el is hagyható a $d-1$ betű
+		\2 Szóval max annyi kódszó van, hogy a kódszavakat $d-1$ betűvel rövidítve is páronként különbözik mindegyik
+\end{outline}
+
+\subsubsection{Következmény}
+
+\begin{outline}
+	\1 Hibajavító betűk száma $\ge d-1$
+		\2 Azaz legalább ennyivel kell a szándéknál több betűt használni
+	\1 MDS-kód: egyenlőség áll fenn a Singleton-korlát tételében
+\end{outline}
+
+\subsubsection{Reed-Solomon kód}
+
+\begin{outline}
+	\1 Egy MDS-kód
+	\1 Működés
+		\2 $\Sigma=\{f\in R\}$ ahol $R$ egy véges test
+		\2 Szándék: $f$ polinom együtthatói
+		\2 Kód: $f*g$
+		\2 $g$ kódpolinom $d-1$ fokú
+	\1 Tétel: $g$ gyökei páronként különböznek $\implies$ $d$ távolságú a kód
+\end{outline}
+
+\pagebreak
+
+\subsection{Hamming-korlát}
+
+\subsubsection{Tétel}
+
+\begin{outline}
+	\1 Legyen
+		\2 $Q=|\Sigma|$ az abécé mérete
+		\2 $c$ a kódszavak száma
+		\2 $n$ a kódszavak hossza
+		\2 $t$ hibát javít a kód ($\implies 2t+1$ vagy $2t+2$ távolságú)
+	\1 Állítás: $c * \sum_{k=0}^{t}(\binom{n}{k} * (Q-1)^k) \le Q^n$
+		\2 Szummán belül: kódszótól pontosan $k$ távolságra hány kódszó van
+		\2 Válasz: $\binom{n}{k}=$"hol változtatok" $*$ "mire változtatok"$=(Q-1)^k$
+		\2 Szóval a szumma: kódszótól $\le t$ távolságra lévő szavak száma
+		\2 $Q^n$ pedig az ábécéből kirakható $n$ hosszú szavak száma.
+	\1 Bizonyítás
+		\2 A szumma eredményében "megszámolt" szavak diszjunktak különböző "kiindulási" kódszó esetén, hiszen $t$ hibát javít a kód.
+		\2 Így a (diszjunkt halmazok száma) $*$ (diszjunkt halmaz mérete) nem lehet nagyobb, mint a lehetséges szavak száma.
+\end{outline}
+
+\subsubsection{Következmény}
+
+\begin{outline}
+	\1 Perfekt kód: egyenlőség áll fenn a Hamming-korlát tételében
+\end{outline}
+
+\pagebreak
+
+\section{ZH 2 összefoglaló}
+
+\subsection{Gyűrű, integritási tartomány, test}
+
+\begin{outline}
+	\1 Gyűrű: $*$ disztributív $+$-ra, $+$ asszoc. és kommutatív, $*$ asszoc. és $\exists 0$
+	\1 Integritási tartomány: gyűrű, $*$ kommutatív, nullosztómentes (pl. $\mathbb{Z}_{prim}$)
+	\1 E.I.T.: integritási tartomány, $\exists 1$
+	\1 Test: E.I.T. ahol van osztás ($\forall a \ne 0: \exists a^{-1}$) (pl. $\mathbb{Q}, \mathbb{Z}_{prim}$)
+	\1 Gyűrű elem (additív) rendje: legkisebb $n$ egész, hogy $n*$ az elem  $=0$
+	\1 $char(R)$: I.T. elemeinek (megegyező) rendje (pl. $char(\mathbb{Z}_{prim})=prim$)
+		\2 $char(R)=0$ ha az elemek rendje nem véges, pl. $char(\mathbb{Z})$, $char(\mathbb{Q})$
+\end{outline}
+
+\subsection{Polinom alapok}
+
+\begin{outline}
+	\1 $f = f_0 + ... + f_{\deg f}*x^{\deg f}$ ahol $\deg f=$ legnagyobb $n$ ahol $f_n \ne 0$
+		\2 $f = 0 \implies \deg f = -\infty$
+	\1 $\deg f+g \le max(\deg f, \deg g)$
+	\1 $\deg f*g \le \deg f + \deg g$ (egyenlő, ha $R$ egy I.T, azaz nullosztómentes)
+	\1 Maradékos osztás: $f=g*q+r \wedge \deg r < \deg q$: ($R$ egy E.I.T, $\exists {g_{\deg g}}^{-1}$)
+		\2 Bizonyítások: egyértelműség: fokszámmal; létezés: rekurzióval
+		\2 Gyakorlatban: rekurzióval, $f^*=f-g*f_{\deg f}*g_{\deg g}^{-1}*x^{\deg f - \deg g}$
+			\3 Alapeset, megállás: $\deg f < \deg g$ (ekkor $r=f$)
+			\3 $q=\sum f_{\deg f}*g_{\deg g}^{-1}*x^{\deg f - \deg g}$ (ahol $f$ persze változik)
+	\1 Gyökök: $c$ gyök ha $f(c)=0$, ekkor $f=q*(x-c)$
+		\2 Ha $R$ egy E.I.T. akkor $f$-nek legfeljebb $\deg f$ darab gyöke van
+	\1 Egység: mindennek az osztója (polinom egység, ha $\forall$ polinomnak osztója)
+		\2 $R$ egy test: pontosan nemnulla konstans polinomok az egységek
+		\2 Gyűrűelem egységgel szorzása: osztói, többszörösei nem változnak.
+		\2 Egy gyűrű elemei asszociáltak, ha egymás egységszeresei
+	\1 Algebrai derivált: $f'=\sum_{k=0}^{\deg f} k * f_k * x^{k-1}$
+\end{outline}
+
+\pagebreak
+
+\subsection{Horner-elrendezés (Horner táblázat)}
+
+\begin{table}[h!]
+	\centering
+	\begin{tabular}{|c|c|c|c|c|c|c|}
+		\hline
+		& $f_n$ & $f_{n-1}$ & $f_{n-2}$ & ... & $f_0$ & \\
+		\hline
+		c & $\times$ & $c_1=f_n$ & $c_2=c_1*c+f_{n-1}$ & .. & $c_n=c_{n-1}*c+f_1$ & $c_{n+1}=...=f(c)$ \\
+		\hline
+	\end{tabular}
+\end{table}
+
+\subsection{Felbonthatatlan (irreducibilis) polinomok}
+
+\begin{outline}
+	\1 $f \ne 0$ irreducibilis ha nem egység és $f=g*h \implies$ $g$ vagy $h$ egység
+	\1 Test felett: $\deg f = 1 \implies f$ irreducibilis
+	\1 $\mathbb{C}$-ben: irreducibilis $\Leftrightarrow$ elsőfokú polinom (algebra alaptétele $\mathbb{C}$-ben)
+	\1 $\mathbb{Z}_{prim}$, $\mathbb{Q}$, $\mathbb{Z}$: minden $n \ge 1$-re létezik $n$-ed fokú irreducibilis polinom
+\end{outline}
+
+\subsection{Gyökök multiplicitása}
+
+\begin{outline}
+	\1 $c$ legalább $k$-szoros gyök $\implies \exists q: f=(x-c)^k*q$
+	\1 $f$-nek a $c$ $k$-szoros gyöke $\implies$ $f'$-nek $c$ min. $(k-1)$-szeres gyöke
+		\2 Bizonyítás: $f=(x-c)^k*q$ deriválása (szorzat deriváltja azonosság)
+		\2 "min" helyett "pontosan" ha $char(R) \not | \; k$ (mert pl. $char(\mathbb{R})=0$)
+	\1 $char(R)=0 \implies LNKO(f,f')$ gyökei az $f$ legalább kétszeres gyökei
+\end{outline}
+
+\subsection{(Bővített) euklideszi algoritmus}
+
+\begin{outline}
+	\1 Test felett működik; nem egyértelmű: egységgel részeredményeket megszorozhatjuk
+	\1 Gyakorlatban: $f,g,r_1,r_2,...$ kettesével osztása megadja a következőt
+	\1 Ugyan úgy megy, mint skalárokkal; utolsó nemnulla az eredmény
+\end{outline}
+
+\subsection{Kétváltozós diofantikus egyenletek}
+
+\begin{outline}
+	\1 $u,v=?$ \;\; és \;\; $f*u+g*v=h$ \;\; és \;\; $f*u'+g*v'=d=gcd(f,g)$
+	\1 Megoldható $\Leftrightarrow d|h$
+	\1 Megoldások, ahol $w \in R[x]$ tetszőleges:
+		\2 $u_w = u_0+\frac{g}{d}w$ ahol $u_0=u'*\frac{h}{d}$
+		\2 $v_w = v_0-\frac{f}{d}w$ ahol $v_0=v'*\frac{h}{d}$
+\end{outline}
+
+\end{document}
diff --git "a/dimat2/sz\303\241melm\303\251let/dimat2-sz\303\241melm\303\251let.pdf" "b/dimat2/sz\303\241melm\303\251let/dimat2-sz\303\241melm\303\251let.pdf"
new file mode 100644
index 0000000..3b57c18
Binary files /dev/null and "b/dimat2/sz\303\241melm\303\251let/dimat2-sz\303\241melm\303\251let.pdf" differ
diff --git "a/dimat2/sz\303\241melm\303\251let/dimat2-sz\303\241melm\303\251let.tex" "b/dimat2/sz\303\241melm\303\251let/dimat2-sz\303\241melm\303\251let.tex"
new file mode 100644
index 0000000..cd7b49f
--- /dev/null
+++ "b/dimat2/sz\303\241melm\303\251let/dimat2-sz\303\241melm\303\251let.tex"
@@ -0,0 +1,749 @@
+% !TeX spellcheck = hu_HU
+\documentclass[12pt,a4paper]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{cmap}
+\usepackage[T1]{fontenc}
+\usepackage[magyar]{babel}
+\usepackage{amsmath}
+\usepackage{amsfonts}
+\usepackage{amssymb}
+\usepackage{graphicx}
+
+\usepackage{outlines}
+\usepackage{hyperref}
+
+\hyphenpenalty=10000
+
+\begin{document}
+
+\begin{center}
+	\huge
+	Diszkrét matematika II\\
+	\vspace{1mm}
+	\LARGE
+	Számelmélet témakör jegyzete\\
+	\vspace{5mm}
+	\large
+	Készült Burcsi Péter előadásai\\
+	és Harrison-Juhász Zsófia gyakorlatai alapján\\
+	\vspace{5mm}
+	Sárközi Gergő, 2021-22-1. félév\\
+	Nincsen lektorálva!
+\end{center}
+
+\tableofcontents
+
+\pagebreak
+
+\section{Oszthatóság}
+
+\subsection{Definíció}
+
+\begin{outline}
+	\1 $a,b \in \mathbb{Z}: \exists c \in \mathbb{Z}: a*c=b \implies a|b$
+		\2 TODO nem kétirányú a reláció?
+	\1 elnevezés: a osztója b-nek, b többszöröse a-nak, a osztja b-t
+	\1 példa: $3|21$, $7|105$
+	\1 $0|0$
+\end{outline}
+
+\subsection{$\mathbb{Z}$-beli oszthatóság}
+
+\begin{outline}
+	\1 $\forall a: 1|a$
+	\1 $\forall a: a|a$ (reflexív)
+	\1 $\forall a: a|0$
+	\1 $\forall a: 0|a \implies a=0$
+	\1 $\forall a,b,k: a|b \implies a*k|b*k$
+	\1 $\forall a,b: a|b \wedge a'|b' \implies aa'|bb'$
+	\2 bizonyítás: $ak=b$ és $a'k'=b'$, tehát $aa'*kk'=bb'$
+	\1 $\forall a,b,k: k \ne 0 \wedge ak|bk \implies a|b$
+	\1 $\forall a,b,c: (a|b \wedge b|c) \implies a|c$ (tranzitív)
+\end{outline}
+
+\subsection{$\mathbb{N}$-beli oszthatóság}
+
+\begin{outline}
+	\1 minden igaz, amit felsoroltam $\mathbb{Z}$ alatt
+	\1 ha az alaphalmaz $\mathbb{N}$, akkor
+	$a,b \in \mathbb{N}: (a|b) \Leftrightarrow (\exists c \in \mathbb{N}: a*c=b)$
+		\2 TODO Ez $\mathbb{Z}$-ben is igaz, nem? lásd 1.4 lin komb bizonyítás
+	\1 $\forall a,b: (a|b \wedge b|a) \implies a=b$ (antiszimmetria)
+		\2 $\mathbb{Z}$-ben nem igaz: $7|-7$ és $-7|7$
+	\1 reflexív, antiszimmetrikus és tranzitív: tehát részbenrendezés $\mathbb{N}$-ben
+\end{outline}
+
+\pagebreak
+
+\subsection{Lineáris kombincáiós tulajdonság}
+
+\begin{outline}
+	\1 Legyen:
+		\2 $a\in \mathbb{Z}$
+		\2 $b_1, b_2, ..., b_n \in \mathbb{Z}$
+		\2 $\forall i: a|b_i$
+	\1 Akkor:
+		\2 $a| \sum_{i=1}^{n} x_i*b_i$ ($x_1,x_2, ..., x_n \in \mathbb{Z}$)
+	\1 Bizonyítás:
+		\2 $a|b_i \Leftrightarrow \exists k_i : a*k_i = b_i$
+		\2 $\sum_{i=1}^{n}x_i*b_i = \sum_{i=1}^{n}x_i*a*k_i = a * \sum_{i=1}^{n}x_i*k_i$
+	\1 Következmények:
+		\2 $a|b \wedge a|c \implies a|(k_1*b+k_2*c)$ ($k_i \in \mathbb{Z}$)
+\end{outline}
+
+\pagebreak
+
+\section{Legnagyobb közös osztó}
+
+\begin{outline}
+	\1 $a,b,d \in \mathbb{Z}$ ('d' 'a' és 'b' legnagyobb közös osztója, ha...)
+	\1 $d|a$ és $d|b$ (közös osztó)
+	\1 $\forall d' \in \mathbb{Z}: (d'|a \wedge d'|b) \implies d'|d)$ (legnagyobb = minden másik osztja)
+	\1 Példa: 18, 30-nak 6 és -6 is LNKO
+\end{outline}
+
+\subsection{LNKO létezésének bizonyítása}
+
+\begin{outline}
+	\1 Tétel: $a,b \in \mathbb{Z} \implies \exists d:LNKO \wedge \exists x,y \in \mathbb{Z}:
+ax+by=d$
+	\1 Bizonyítás:
+		\2 elég a,b > 0-ra belátni
+		\2 ha $0<b<a$ akkor \{a és b közös osztói\} = \{a-b és b közös osztói\}
+			\3 lineáris kombináció miatt igaz:
+			\3 $(d|a \wedge d|b) \implies d|a-b = 1*a-1*b$
+			\3 $(d|a-b \wedge d|b) \implies d|a = 1*(a-b)+1*b$
+		\2 lépés: (\{\} jelezze a rendezetlen párt, ne a halmazt)
+			\3 ha $a>b$ akkor $\{a,b\} \to \{a-b, b\}$
+			\3 ha $b \ge a$ akkor $\{a,b\} \to \{b-a, a\}$
+			\3 ez nem változtatja meg a közös osztókat
+		\2 előbb-utóbb 0-hoz és egy pozitív számhoz jutunk
+		\2 tehát létezik LNKO
+		\2 $\exists s,t: d=(a-b)*s+b*t \implies \exists x,y:d=a*x+b*y$
+			\3 megoldás: x=s, y=t-s
+\end{outline}
+
+\pagebreak
+
+\subsection{Bővített euklideszi algoritmus}
+
+\begin{outline}
+	\1 Bemenet: $a,b \in \mathbb{Z}^+$
+	\1 Kimenet: $d,x,y \in \mathbb{Z}$ (d az LNKO és $d=ax+by$)
+	
+\end{outline}
+
+\begin{verbatim}
+function extended_gcd(a, b)
+    (old_r, r) := (a, b)
+    (old_s, s) := (1, 0)
+    (old_t, t) := (0, 1)
+    while r != 0 do
+        quotient := old_r div r //egészrészes osztás
+        (old_r, r) := (r, old_r - quotient × r)
+        (old_s, s) := (s, old_s - quotient × s)
+        (old_t, t) := (t, old_t - quotient × t)
+    return (old_r, old_t, old_s) //t=x, s=y
+
+//Extra: normál, nem bővített euklideszi algoritmus
+function gcd(a, b)
+    while b != 0
+        t := b
+        b := a mod b
+        a := t
+    return a
+\end{verbatim}
+
+\begin{outline}
+	\1 d=LNKO: \{a és b közös osztói\} = \{d osztói\}
+		\2 mert minden lépésnél d osztja r-t és old-r-t
+	\1 lineáris kombinációs rész, indukció:
+		\2 (d osztja a-t és b-t, tehát a és b lineáris kombinációt is)
+		\2 eredeti old-r = a = a*old-s + b*old-t
+		\2 eredeti r = b = a*s + b*t
+		\2 következő r is lineáris kombináció lesz
+\end{outline}
+
+\pagebreak
+
+\subsection{Euklideszi algoritmus a gyakorlatban}
+
+$a = b * q_1 + r_1$ \\
+$b = r_1 * q_2 + r_2$ \\
+$r_1 = r_2 * q_3 + r_3$ \\
+$...$ \\
+Ha $r_i=0$, akkor $lnko(a,b)=r_{i-1}$ \\
+Ezt táblázatként a bővített algoritmus részeként láthatjuk.
+
+\subsection{Bővített euklideszi algoritmus a gyakorlatban}
+
+Kezdő értékek:\\
+$r_{-1} = a$, $r_0 = b$\\
+$x_{-1} = 1$, $x_0 = 0$\\
+$y_{-1} = 0$, $y_0 = 1$\\
+\\
+Minden $i \ge 1$ esetén:\\
+$q_i = \lfloor r_{i-2} / r_{i-1} \rfloor $\\
+$x_i = x_{i-2} - q_i * x_{i-1}$\\
+$y_i = y_{i-2} - q_i * y_{i-1}$\\
+$r_i = a*x_i + b*y_i$
+
+\begin{table}[h]
+\begin{tabular}{|c|c|c|c|c|}
+	\hline
+	i & $q_i$ & $r_i$ & $x_i$ & $y_i$ \\
+	\hline
+	-1 & - & \textbf{a} & 1 & 0 \\
+	\hline
+	0 & - & \textbf{b} & 0 & 1 \\
+	\hline
+	... & ... & ... & ... & ... \\
+	\hline
+	i & $\lfloor r_{i-2}/r_{i-1} \rfloor$ & $r_{i-2} \mod r_{i-1}$ &
+	$x_{i-2}-q_i*x_{i-1}$ & ... \\
+	\hline
+	... & ... & ... & ... & ... \\
+	\hline
+	n-1 & ? & \textbf{lnko(a,b)} & \textbf{?} & \textbf{?} \\
+	\hline
+	n & ? & \textbf{0} & ... & ... \\
+	\hline
+\end{tabular}
+\end{table}
+
+\begin{table}[h]
+\begin{tabular}{|c|c|c|c|c|}
+	\hline
+	i & $q_i$ & $r_i$ & $x_i$ & $y_i$ \\
+	\hline
+	-1 & - & \textbf{86} & 1 & 0 \\
+	\hline
+	0 & - & \textbf{31} & 0 & 1 \\
+	\hline
+	1 & 2 & 24 & 1 & -2 \\
+	\hline
+	2 & 1 & 7 & -1 & 3 \\
+	\hline
+	3 & 3 & 3 & 4 & -11 \\
+	\hline
+	4 & 2 & \textbf{1} & \textbf{-9} & \textbf{25} \\
+	\hline
+	5 & 3 & \textbf{0} & - & - \\
+	\hline
+\end{tabular}
+\end{table}
+
+\pagebreak
+
+\section{Prímszámok}
+
+\subsection{Prím vs felbonthatatlan}
+
+\begin{outline}
+	\1 $f \in \mathbb{Z}$ felbonthatatlan (irreducibilis), ha $f \ne 0$, $f \ne \pm 1$
+	és $f$-nek a $\pm 1$ és $\pm f$-en (triviális osztókon) kívül nincs más osztója
+			\2 $f=a*b \implies (a = \pm 1) \lor (b = \pm 1)$
+	\1 $p \in \mathbb{Z}$ primszám (rendelkezik a prímtulajdonsággal),\\
+	ha $p \ne 0$ és $p \ne \pm 1$ és $\forall a,b \in \mathbb{Z}: p|a*b \implies p|a \lor p|b$
+		\2 nem prím példa: $15|3*5$, de $15 \not | 3$ és $15 \not | 5$
+\end{outline}
+
+\subsection{Felbonthatatlan = prím}
+
+\begin{outline}
+	\1 Cél: felbonthatatlanság $\Leftrightarrow$ prímtulajdonság
+	\1 Bizonyítás: p prím $\implies$ p felbonthatatlan
+		\2 Indirekt, Tfh. (tegyük fel hogy) $p=a*b$ ($a \ne \pm 1$, $a \ne \pm p$)
+		\2 $p|a*b \implies \text{(mert prím) } p|a \lor p|b$
+		\2 $p=a*b \implies a|p \wedge b|p$
+		\2 $p|a \wedge a|p \implies p=\pm a$ ($a$ helyett $b$-re ugyan ezek felírhatók)
+		\2 ellentmondás
+	\1 Bizonyítás: f felbonthatatlan $\implies$ f prím
+		\2 f-nek 4 osztója van: $\pm 1, \pm f$
+		\2 kérdés, hogy igaz-e: $f|a*b \implies f|a \lor f|b$
+		\2 ha $f|a*b$, de $f\not | a$:
+			\3 f és a közös osztói: $\pm 1$ (egyben LNKO)
+			\3 LNKO = 1 = $x*f+y*a$ (lásd LNKO szekció)
+			\3 /*b után: $b = b*x*f + b*y*a$
+			\3 $f$ osztja az első tagot: $f|b*x*f$
+			\3 $f|a*b$ (kikötés), tehát f osztja a második tagot: $f|a*y*b$
+			\3 tehát $f$ osztja $b$-t is, hiszen $b$ felírható
+			olyan számok lineáris kombinációjaként, amiket $f$ oszt
+\end{outline}
+
+\pagebreak
+
+\subsection{Számelmélet alaptétele}
+
+\begin{outline}
+	\1 Legyen $n \in \mathbb{Z}, n \ne 0, n \ne \pm 1$. Ekkor $n$ lényegében
+	(előjeltől és sorrendtől eltekintve) felirható prímszámok szorzataként.
+	\1 Bizonyítás: létezik felírás
+		\2 Elég $n \ge 2$ esetben
+		\2 Indukció: $n=2$
+		\2 Legyen $n>2$. Minden n-nél kisebbhez létezik felírás
+		\2 Ha n prím, akkor kész vagyunk
+		\2 Ha n nem prím, akkor $\exists 1<n_1,n_2<n: n=n_1*n_2$
+			\3 De ekkor n felírható $n_1$ és $n_2$ szorzataként, szóval van felírás
+	\1 Bizonyítás: egyértelműség
+		\2 Tfh. $n=p_1*p_2*...*p_r=q_1*q_2*...*q_s$ ($p_i$ és $q_i$ prímek)
+		\2 $p_1$ prím és $p_1 | q_1*q_2*...*q_s$ ezért $\exists l$ index, hogy $p_1|q_l$
+			\3 de $q_l$ prím, azaz osztói: $\{\pm 1, \pm q\}$
+			\3 $p_1$ nem lehet $\pm 1$, mert prím
+			\3 tehát $p_1 = \pm q_l$
+		\2 Folytatva: $\frac{n}{p_1}=p_2*...*p_r=\pm q_1*...*q_{l-1}*q_{l+1}*...*q_s=\pm\frac{n}{q_l}$
+		\2 Azaz kisebb számmal folytatjuk, így előbb-utóbb végzünk és arra jutunk,
+		hogy a két szorzat pontosan ugyanazokat a tényezőket tartalmazza
+		(sorrendtől és előjeltől eltekintve)
+\end{outline}
+
+\subsection{Tétel: végtelen sok prím van}
+
+\begin{outline}
+	\1 Tfh. összesen $n$ prím van: $p_1,p_2,...,p_n$
+	\1 $x=p_1*p_2*...*p_n+1$
+	\1 $x$ felbontható prímekre, hiszen minden szám felbontható prímekre
+	\1 $x-1$ osztható az összes prímmel, tehát $x$ nem osztható egyikkel sem (ellentmondás)
+\end{outline}
+
+\pagebreak
+
+\subsection{Prímszámtétel}
+
+\begin{outline}
+	\1 $\lim\limits_{x\to\infty} \frac{\pi(x)}{x/ln(x)}=1$, ahol $\pi(x)=1\le p < x$ prímek száma
+	\1 Jelentés: prímek száma nagyjából $\frac{x}{ln(x)}$
+	\1 Random szám x körül: $1/ln(x)$ eséllyel prím
+		\2 $ln(x)$ arányos $x$ számjegyeinek számával
+\end{outline}
+
+\subsection{Prímfelbontás kanonikus alakja}
+
+\begin{outline}
+	\1 Prímfelbontás kanonikus alakja: $n=p_1^{\alpha_1}*p_2^{\alpha_2}*...$ (ahol $p_i$ különböző)
+	\1 n osztói pontosan azok az $m=p_1^{\beta_1}*p_2^{\beta_2}*...$
+	számok ahol $\forall i: 0 \le \beta_i \le \alpha_i$
+	\1 Bizonyítás:
+		\2 $m$-nek lenne más prímosztója $q$
+		\2 $q|m \wedge m|n \implies q|n \implies$ q n egy tényezője, ellentmondás
+\end{outline}
+
+\subsection{Szám osztóinak száma}
+
+\begin{outline}
+	\1 $n=p_1^{\alpha_1}*p_2^{\alpha_2}*...$ szám pozitív osztóinak száma:
+	$(\alpha_1+1)*(\alpha_2+1)*...$
+	\1 mert $\beta_i$-re ennyi lehetőség van
+\end{outline}
+
+\subsection{LNKO kiszámítása prímtényezőkből}
+
+\begin{outline}
+	\1 $n=p_1^{\alpha_1}*p_2^{\alpha_2}*...$ és $m=p_1^{\beta_1}*p_2^{\beta_2}*...$
+	és $\alpha_i=0$, $\beta_i=0$ is meg van engedve
+	\1 $LNKO(n,m)=p_1^{min(\alpha_1,\beta_1)}*p_2^{min(\alpha_2,\beta_2)}*...$
+\end{outline}
+
+\pagebreak
+
+\section{Legkisebb közös többszörös}
+
+\subsection{Definíció}
+
+\begin{outline}
+	\1 Legyen $n,m \in \mathbb{Z}$ és $t=LKKT(n,m) \in \mathbb{Z}$
+	\1 Ekkor $n|t \wedge m|t$ és $\forall t': (n|t' \wedge m|t') \implies t|t'$
+	\1 Kettő LKKT van, normáls esetben a pozitívra gondolunk
+\end{outline}
+
+\subsection{Kiszámítása}
+
+\begin{outline}
+	\1 Ha $n=p_1^{\alpha_1}*p_2^{\alpha_2}*...$ és $m=p_1^{\beta_1}*p_2^{\beta_2}*...$
+	\1 Ekkor $LKKT(n,m) = p_1^{max(\alpha_1,\beta_1)}*p_2^{max(\alpha_2,\beta_2)}*...$
+\end{outline}
+
+\subsection{LNKO, LKKT kapcsolata}
+
+\begin{outline}
+	\1 $LNKO(a,b)*LKKT(a,b)=a*b$
+	\1 Tehát LKKT-t ki lehet számítani a két szám szorzatából és LNKO-ból
+\end{outline}
+
+\pagebreak
+
+\section{Kongruencia}
+
+\subsection{Definíció}
+
+\begin{outline}
+	\1 $m,a,b \in \mathbb{Z}$ esetén $a \equiv b \pmod m \Leftrightarrow m|a-b$
+	\1 Másik jelölés: $a \equiv b$ (m)
+\end{outline}
+
+\subsection{Tulajdonságok}
+
+\begin{outline}
+	\1 reflexív: $\forall a: a \equiv a \pmod m$
+	\1 szimmetrikus: $\forall a,b: a \equiv b \pmod m \Leftrightarrow b \equiv a \pmod m$
+		\2 $m|a-b \Leftrightarrow m|b-a$ (mindkettő lineáris kombináció)
+	\1 tranzitív: $\forall a,b,c: a \equiv b \pmod m \wedge b \equiv c \pmod m$\\
+	$\implies a \equiv c \pmod m$
+		\2 $m|a-b \wedge m|b-c \implies m|a-c$ (mert $a-c=(a-b)+(b-c)$)
+	\1 reflexív, szimmetrikus, tranzitív: ekvivalencia reláció
+		\2 mod m szerinti osztályok: m szerinti (modulo m) maradékosztályok
+\end{outline}
+
+\pagebreak
+
+\subsection{Modulus tulajdonságai, gyakorlatról trükkök}
+
+\begin{outline}
+\1 $a+b \mod m = (a \mod m + b \mod m) \mod m$
+\1 $a*b \mod m = (a \mod m) * (b \mod m) \mod m$
+\1 $a^x \mod m = (a \mod m)^x \mod m$
+\1 Kis-fermat tétel: $a^p \mod p = a^1 \mod p$ \;\; (ahol $p$ prím)
+\2 Átfogalmazva: $a^{p-1} \mod p = 1$
+\2 Következmény: $a^x \mod p = a^{(x \mod (p-1))} \mod p$
+\end{outline}
+
+\subsubsection{Ekvivalens átalakítás}
+
+\begin{outline}
+	\1 Legyen a kongruencia $a \equiv b \mod m$
+	\1 $c \ne 0$-val szorozni $a$-t, $b$-t és $m$-t
+	\1 Legyen $c \ne 0$ és $gcd(m,c)=1$, ekkor $a$, $b$ beszorozható $c$-vel ($m$ marad) 
+	\1 Legyen $c \ne 0$, hogy $c | a$ és $c | b$, ekkor $a$ és $b$ leosztható $c$-vel, $m$ pedig leosztható $gcd(m,c)$-vel
+\end{outline}
+
+\subsubsection{Gyorshatványozás}
+
+($n^x \mod m$):  az $x$ szám felírása 2-es számrendszerben
+és $n^{(2^k)} \mod m$ értékekhez táblazatot készíteni ($k \in \mathbb{N}_0$).
+Itt a következő érték mindig az előző érték négyzete, mod m.
+Ekkor az $n$ kettő hatványokra emelt mod m értékeiből összerakni az $n^x$ értéket:
+$n^x \mod m = (\prod n^{(2^k)} \mod m) \mod m$
+
+\paragraph{Példa} Legyen a feladat $2019^{10} \mod 7$ \\
+$10$ a kettes számrendszerben: $1010$ \\
+Tehát $2019^{10} = 2019^{2^3}*2019^{2^1}$ \\
+Tudjuk, hogy $2019^{10} \mod 7 = (2019^{2^3} \mod 7)*(2019^{2^1} \mod 7)$ \\
+A táblázatban számoljuk ki $2019^{(2^k)} \mod 7$ értékeket \\
+Tudjuk, hogy $2019^{(2^k)} \mod 7 = (2019 \mod 7)^{(2^k)} \mod 7$ \\
+Tudjuk, hogy $2019^{(2^{k+1})} \mod 7 = (2019^{(2^k)} \mod 7)^2 \mod 7$ \\
+Táblázatból kiolvasva: $2019^{10} \mod 7 = (2*2) \mod 7$
+
+\begin{table}[h]
+\centering
+\begin{tabular}{|c|c|c|c|c|}
+	\hline
+	k & 0 & 1 & 2 & 3 \\
+	\hline
+	$2019^{(2^k)} \mod 7$ & 3 & 2 & 4 & 2 \\
+	\hline
+\end{tabular}
+\end{table}
+
+\pagebreak
+
+\subsection{Kínai maradéktétel}
+
+\subsubsection{Állítás}
+
+\begin{outline}
+	\1 Legyen $m_1,m_2,...,m_n$ tetszőleges 1-nél nagyobb egészek, melyek páronként relatív prímek
+		\2 páronként relatív prím: $i \ne j \implies LNKO(m_i,m_j)=1$
+	\1 Ekkor
+		\2 az alábbi szimultán kongruenciarendszer megoldható minden $a_1,a_2,...,a_n$ egészek esetén
+		\2 az $x$-ek maradékosztályt alkotnak modulo $M=m_1*m_2*...*m_n$
+	\1 $x \equiv a_1 \mod m_1$\\
+	$x \equiv a_2 \mod m_2$\\
+	...\\
+	$x \equiv a_n \mod m_n$
+\end{outline}
+
+\subsubsection{Bizonyítás}
+
+\begin{outline}
+	\1 Legyen $n=2$ (ha nagyobb, akkor indukcióval megoldható)
+	\1 $LNKO(m_1,m_2)=1=m_1*x_1+m_2*x_2$
+	\1 $A=a_2*m_1*x_1+a_1*m_2*x_2$
+		\2 $A \equiv 0+a_1*m_2*x_2 \mod m_1$
+		\2 $1=m_1*x_1+m_2*x_2 \implies 1 \equiv m_1*x_1+m_2*x_2 \mod $bármi
+		\2 $1 \equiv m_1*x_1+m_2*x_2 \equiv m_2*x_2 \mod m_1$
+		\2 $A \equiv a_1*m_2*x_2 \equiv a_1 \mod m_1$
+	\1 $A \equiv a_1 \mod m_1$ és $A \equiv a_2 \mod m_2$
+	\1 Ezért $x \equiv A \mod m_1*m_2$
+	\1 Be kell látni: $A$ és $A'$ is jó $\implies A \equiv A' \mod m_1*m_2$
+		\2 $A' \equiv A \equiv a_1 \mod m_1 \implies m_1 | A-A'$
+		\2 $A' \equiv A \equiv a_2 \mod m_2 \implies m_2 | A-A'$
+		\2 Ezekből következik: $m_1*m_2|A-A'$ ($m_1$, $m_2$ relatív prímek)
+\end{outline}
+
+\pagebreak
+
+\subsection{Euler-Fermat tétel}
+
+\subsubsection{Bevezetés}
+
+\begin{outline}
+	\1 $ax \equiv ax' \mod m$ és $(a,m)=1$ akkor $x \equiv x' \mod m$
+		\2 Bizonyítás: $ax \equiv ax' \mod m$
+		\2 $\Leftrightarrow m | ax-ax'=a(x-x')$
+		\2 $\implies$ (mert $(a,m)=1$) $\implies m|(x-x')$
+		\2 $\Leftrightarrow x \equiv x' \mod m$
+	\1 Általánosabban: $ax \equiv ax' \mod m \implies x \equiv x' \mod \frac{m}{(a,m)}$
+\end{outline}
+
+\subsubsection{Euler-féle $\varphi$ függvény}
+
+\begin{outline}
+	\1 $\varphi(m)=|\{x=1,...,m \;|\; (x,m)=1\}|$
+		\2 azaz $1$ és $m$ közötti, $m$-mel relatív prím számok száma
+	\1 Példa: $\varphi(10)=4$, mert: 1,3,7,9
+\end{outline}
+
+\subsubsection{Euler-Fermat tétel}
+
+\begin{outline}
+	\1 $(a,m)=1 \implies a^{\varphi(m)} \equiv 1 \mod m$
+		\2 Máshogy: $a^x \equiv a^{x \mod \varphi(m)} \mod m$
+	\1 Bizonyítás:
+		\2 Legyen $a_1, a_2, ..., a_{\varphi(m)}$ mindegyike egy különböző szám\\
+		$\{0,1,...,\varphi(m)-1\}$-ből (melyek relatív prímek m-hez)
+		\2 $a*a_1, a*a_2, ..., a*a_{\varphi(m)}$ páronként különböznek mod m
+			\3 $a*a_i \equiv a*a_j \implies a_i \equiv a_j \implies$ ellentmondás
+		\2 tehát a $a_1,...,a_{\varphi(m)}$ és a $a*a_1,...,a*a_{\varphi(m)}$ maradékosztályok
+		ugyan azok, legfeljebb más sorrendben
+			\3 redukált maradékrendszerek, ezeket viszont nem vettük
+		\2 $\implies a_1*...*a_{\varphi(m)} \equiv (a*a_1)*...*(a*a_{\varphi(m)}) \mod m$
+		\2 $\implies a_1*...*a_{\varphi(m)} \equiv a^{\varphi(m)} * (a_1*...*a_{\varphi(m)}) \mod m$
+		\2 $\implies 1 \equiv a^{\varphi(m)} \mod m$
+	\1 Példa: $7^4 \equiv 1 \mod 10$
+\end{outline}
+
+\pagebreak
+
+\subsubsection{Euler-féle $\varphi$ függvény kiszámítása}
+
+\begin{outline}
+	\1 Állítás:
+		\2 Legyen $m=p^\alpha$ valami $p$ prímre, $\alpha \ge 1$
+		\2 Akkor $\varphi(m) = p^\alpha - p^{\alpha-1} = (p-1)*p^{\alpha-1} = \frac{p-1}{p}*m$
+		\2 Példa: $\varphi(125)=\varphi(5^3)=5^3-5^2=100$
+	\1 Bizonyítás:
+		\2 $LNKO(p^\alpha,a)=1 \Leftrightarrow p \not | a$
+		\2 $\varphi(p^\alpha)=|\{a=1,...,p^\alpha \;|\; p \not | a\}|=p^\alpha - p^{\alpha-1}$
+			\3 Mert $p$-vel $p^{\alpha-1}$ pozitív szám osztható (ami $\le p^\alpha$)
+			\3 Más megközelítés: minden $p$-edik szám kiesik, azaz $p^{\alpha-1}$ darab
+	\1 Állítás: $\varphi$ multiplikatív
+		\2 Legyen $a,b$ relatív prímek
+		\2 $\varphi(a*b)=\varphi(a)*\varphi(b)$
+	\1 Bizonyítás:
+		\2 $x \equiv a_1 \mod a$ és $x' \equiv a_1 \mod a$ esetén: $lnko(x,a)=lnko(x',a)$
+		\2 Tehát $x$ relatív prím $a*b \Leftrightarrow$ $x$ relatív prím $a$ és $b$
+		\2 Ez kell: $x \equiv a_1 \mod a$ és $x \equiv b_1 \mod b$
+			\3 ahol $lnko(a,a_1)=1$ és $lnko(b,b_1)=1$
+		\2 $a_1$-ből $\varphi(a)$ db van, stb.
+		\2 Kínai maradéktétel miatt biztos van megoldás
+	\1 Következmény:
+		\2 Ha $n=p_1^{\alpha_1}*p_2^{\alpha_2}*...*p_r^{\alpha_r}$ (kanonikus alak)
+		\2 Akkor $\varphi(n)=\Pi_{k=1..r}(p^{\alpha_k}-p^{\alpha_k-1})=n*\Pi_{k=1..r}(1-\frac{1}{p_k})$
+		\2 Példa: $\varphi(100=2^2*5^2)=(2^2-2^1)(5^2-5^1)=2*20=40$
+\end{outline}
+
+\pagebreak
+
+\subsection{Egyváltozós lineáris kongruenciák}
+
+\begin{outline}
+	\1 $a*x \equiv b \mod m$ ahol $a,b,m$ adott
+	\1 ha $x$ megoldás, akkor minden $x' \equiv x \mod m$ is
+\end{outline}
+
+\subsubsection{Megoldási módszer}
+
+\begin{outline}
+	\1 $ax \equiv b \mod m$
+	\1 Átírva: $\exists y \in \mathbb{Z}: ax-b=my$, azaz $ax+my=b$
+	\1 LNKO(a,m) kiszámítása: $as+mt=d=(a,m)$
+	\1 $(a,m) \not |\; b \implies$ nincs megoldás
+	\1 $(a,m) \;\;|\; b \implies x \equiv s*\frac{b}{(a,m)} \mod \frac{m}{(a,m)}$
+		\2 $(\frac{a}{(a,m)},\frac{m}{(a,m)})=1=\frac{a}{d}*s+ \frac{m}{d}*t$
+		\2 $\implies \frac{a}{(a,m)}*s=1-\frac{m}{(a,m)}*t$
+		\2 $\implies \frac{a}{(a,m)}*s=1-\frac{m}{(a,m)}*t \equiv 1 \mod \frac{m}{(a,m)}$
+		\2 $\implies \frac{a}{(a,m)}*(s*\frac{b}{(a,m)}) \equiv \frac{b}{(a,m)} \mod \frac{m}{(a,m)}$
+	\1 $x'$ megoldás $\Leftrightarrow x \equiv x' \mod \frac{m}{(a,m)}$
+\end{outline}
+
+\subsubsection{Megoldás diofantikus egyenlet alapján}
+
+\begin{outline}
+	\1 $ax \equiv b \mod m \Leftrightarrow \exists y \in \mathbb{Z}: ax+my=b$
+	\1 megoldjuk a diofantikus egyenletet
+	\1 $x_t = x_0 + \frac{m}{(a,m)}t$\;\; ($t=0,1,...,(a,m)-1$)
+	\1 megoldások: $[x_0] \cup [x_1] \cup ... \cup [x_{(a,m)-1}]$
+		\2 $\{x_0 + mk \;|\; k \in \mathbb{Z}\} \cup \{x_1 + mk \;|\; k \in \mathbb{Z}\} \cup ...$
+		\2 $[x]=\{x' \in \mathbb{Z} \;|\; x' \equiv x \mod m\}$
+	\1 egyszerűsítés: ha megoldható, akkor ekvivalens: $\frac{ax}{(a,m)} \equiv \frac{b}{(a,m)} \mod \frac{m}{(a,m)}$
+\end{outline}
+
+\pagebreak
+
+\subsection{Lineáris kongruencia rendszerek}
+
+\subsubsection{Kínai maradéktétellel, páronként relatív prímek esetén}
+
+\begin{outline}
+	\1 Legyen $i$ kongruenciánk: $x \equiv c_i \mod m_i$
+	\1 $m_i$ páronként relatív prímek
+	\1 $i-1$ lépésben oldjuk meg: mindig 2 kongruenciából csinálunk 1 újat
+		\2 Legyen ez a kettő kongruencia $i=1$ és $i=2$
+		\2 $x \equiv c_2*m_1*x_1 + c_1*m_2*x_2 \mod m_1*m_2$
+		\2 Ahol $x_1$ és $x_2$ innen jön: $m_1*x_1+m_2*x_2=1$ (mindig megoldható)
+	\2 Végül egyetlen kongruencia marad: $x \equiv \;? \mod \prod m_i$
+\end{outline}
+
+\subsubsection{Kínai maradéktétellel, nem relatív prímek esetén}
+
+\begin{outline}
+	\1 Legyen $i$ kongruenciánk: $x \equiv c_i \mod m_i$
+	\1 Ha bármelyik $m_j$ és $m_k$ nem relatív prímek, akkor bontsuk őket szét 2 vagy több kongruenciára, hogy azok legyenek, vagy egymás hatványai.
+		\2 Példa: $x \equiv 4 \mod 15$ és $x \equiv 4 \mod 10$
+		\2 Elsőből: $x \equiv 4 \mod 5$ és $x \equiv 4 \equiv 1 \mod 3$
+	\1 Ezek után ha bármelyik $m_j | m_k$ (pl. $2|2$ vagy $2|4$)
+		\2 vagy ellentmondanak egymásnak és nincs megoldás
+		\2 vagy nem mondanak ellen egymásnak, $m_j$ eldobható
+	\1 Ezek után relatív prímek $m_i$-k és megoldhatók a fenti módszerrel
+\end{outline}
+
+\subsubsection{Behelyetessítős módszerrel}
+
+\begin{outline}
+	\1 Legyen $i$ kongruenciánk: $a_i*x \equiv c_i \mod m_i$
+	\1 $i-1$ lépésben oldjuk meg: mindig 2 kongruenciából csinálunk 1 újat
+		\2 Legyen ez a kettő kongruencia $i=1$ és $i=2$
+		\2 Elsőből kifejezzük $x$-et: $x \equiv y \mod m$ (ahol $y$ és $m$ ismert)
+		\2 Felírjuk egyenletként: $x = y + k*m \;\; (k \in \mathbb{Z})$
+		\2 Behelyettesítjük másodikba: $a_2 * (y + k*m) \equiv c_2 \mod m_2 \; (k \in \mathbb{Z})$
+		\2 Megoldjuk $k$-ra: $k \equiv ? \mod ?$
+	\1 Végül egyetlen kongruencia marad: $x \equiv ? \mod ?$
+\end{outline}
+
+\pagebreak
+
+\section{Kétváltozós lineáris diofantikus egyenletek}
+
+\begin{outline}
+	\1 $ax+by=c$ ahol $a,b,c,x,y \in \mathbb{Z}$ és $x,y=?$
+	\1 $(a,b)|c \Leftrightarrow$ megoldható
+	\1 Bővített euklideszi algoritmus: $ap+bq=(a,b)$
+		\2 megszorozva $\frac{c}{(a,b)}$-vel:
+		\2 $x_0=p*\frac{c}{(a,b)}$
+		\2 $y_0=q*\frac{c}{(a,b)}$
+		\2 $ax_0+by_0=c$
+	\1 $ax_t+by_t=c$
+		\2 $x_t=x_0+\frac{b}{(a,b)}t$
+		\2 $y_t=y_0-\frac{a}{(a,b)}t$
+	\1 Ha csak pozitív megoldások érdekelnek:\\
+	$x_t>0 \wedge y_t>0$ egyenletrendszert meg kell oldani
+\end{outline}
+
+\pagebreak
+
+\section{Számrendszerek}
+
+\subsection{Gyakorlati trükkök}
+
+\begin{outline}
+	\1 Számrendszer váltás: a számot folyamatosan leosztjuk az új bázissal. A maradékot feljegyezzük.
+	Ha nullához értünk, akkor végeztünk: a maradékot fordított sorrendben
+	(utoljára feljegyzett van a legtöbbet érő helyiértéken) kiolvassuk.
+\end{outline}
+
+\pagebreak
+
+\section{ZH 1-re összefoglaló jegyzet}
+
+\subsection{Kanonikus alak}
+
+\begin{outline}
+	\1 Legyen $n = p_1^{a_1} * p_2^{a_2} * ...$ és $m = p_1^{b_1} * p_2^{b_2} * ...$
+	\1 $n$ osztóinak száma: $(a_1+1)*(a_2+1)*...$
+	\1 $\varphi(p^a) = p^a - p^{a-1}$ és $\varphi(x*y) = \varphi(x)*\varphi(y)$
+	\1 $LNKO(n,m) = gcd(n,m) = (n,m) = p_1^{min(a_1,b_1)} * p_2^{min(a_2,b_2)} * ...$
+	\1 $LKKT(n,m) = lcm(n,m) = [n,m] = p_1^{max(a_1,b_1)} * p_2^{max(a_2,b_2)} * ...$
+	\1 LNKO, LKKT összefüggés: $n*m = (n,m) * [n,m]$
+\end{outline}
+
+\subsection{Oszthatóság}
+
+\begin{outline}
+	\1 $a,b \in \mathbb{Z}: \exists c \in \mathbb{Z}: a*c=b \implies a|b$
+	\1 $\forall a: 1|a \; \wedge \; a|0$ \;\; viszont $0|a \implies a=0$
+	\1 $a|b \wedge a|c \implies a|(k_1*b+k_2*c)$ \;\; (lineáris kombinációs tulajdonság)
+	\1 $\mathbb{N}$-ben részbenrendezés: reflexív, tranzitív és antiszimmetrikus
+		\2 $\mathbb{Z}$-ben nem antiszimmetrikus: $7|-7$ és $-7|7$
+	\1 Bővített euklideszi algoritmus: $gcd(a,b)=a*x+b*y$ \;\;(q,r,x,y táblázat)
+\end{outline}
+
+\subsection{Kongruencia}
+
+\begin{outline}
+	\1 $m,a,b \in \mathbb{Z}: a \equiv b \mod m \; \Leftrightarrow \; m | a-b$
+	\1 Ekvivalencia reláció: reflexív, szimmetrikus, tranzitív
+	\1 $a*+b \equiv a \mod m *+ b \mod m$ és $a^x \equiv (a \mod m)^x \;\;(mod \; m)$
+\end{outline}
+
+\subsection{Kis-Fermat tétel, Euler-Fermat tétel}
+
+\begin{outline}
+	\1 Kis-Fermat tétel: $p$ prím $\implies a^{p-1} \equiv 1 \mod p$
+	\1 Euler-Fermat tétel: $(a,m)=1 \implies a^{\varphi(m)} \equiv 1 \mod m$
+\end{outline}
+
+\pagebreak
+
+\subsection{Kongruencia ekvivalens átalakításai}
+
+\begin{outline}
+	\1 $a \equiv b \mod m$
+	\1 $c \ne 0$: $ac \equiv bc \mod mc$
+	\1 $gcd(m,c)=1$ és $c \ne 0$: $ac \equiv bc \mod m$
+	\1 $c \ne 0$ és $c|a$ és $c|b$: $\frac{a}{c} \equiv \frac{b}{c} \mod \frac{m}{(m,c)}$
+\end{outline}
+
+\subsection{Kétváltozós lineáris diofantikus egyenletek}
+
+\begin{outline}
+	\1 $ax+by=c$ ahol $x,y$ ismeretlen
+	\1 $(a,b)|c \Leftrightarrow$ megoldható
+		\2 Bővített euklideszi algoritmus: $ap+bq=(a,b)$
+		\2 $a*(p*\frac{c}{(a,b)}) + b*(q*\frac{c}{(a,b)}) = c = a*x_0 + b*y_0$
+		\2 $x_t = x_0 + \frac{b}{(a,b)}t$ \;\; és \;\; $y_t = y_0 - \frac{a}{(a,b)}t$
+	\1 Kongruenciából: $ax \equiv n \mod m \implies \exists y: ax + my = n$
+		\2 Megoldás: $[x_0] \cup [x_1] \cup ...$ ahol $0 \le t < (a,m)$
+		\2 Egyszerűsítés: $\frac{a}{(a,m)}x \equiv \frac{b}{(a,m)} \mod \frac{m}{(a,m)}$
+		\;\; (ekkor csak $t=0$)
+\end{outline}
+
+\subsection{Kongruenciarendszerek, kínai maradéktétel}
+
+\begin{outline}
+	\1 Legyen $i$ db kongruenciánk: $x \equiv c_i \mod m_i$
+	\1 Ha $m_i$ páronként relatív prímek: megoldható, kettesével
+		\2 $x \equiv c_2*m_1*x_1 + c_1*m_2*x_2 \mod m_1*m_2$
+		\2 Ahol $x_1$ és $x_2$ innen jön: $m_1*x_1+m_2*x_2=1$ (mindig megoldható)
+	\1 Egyébként bontsuk kanonikus formára az $m_i$-ket:
+	vagy ellentmondás lesz vagy elhagyható $m_1$ ha $m_1|m_2$ (pl. $2|4$).
+\end{outline}
+
+\subsection{Trükkök}
+
+\begin{outline}
+	\1 Gyorshatványozás: $a^{12}=a^8*a^4$ és $a^8 \equiv (a^4 \mod m)^2 \mod m$\\
+	Azaz mindig csak az előző eredményt kell négyzetre emelni.
+	\1 $(a,m)=1 \implies$ $a^{b^c} \equiv a^n \mod m$ és $n \equiv b^c \mod \varphi(m)$
+\end{outline}
+
+\end{document}
diff --git a/fonya-fordprog/README.md b/fonya-fordprog/README.md
new file mode 100644
index 0000000..e457953
--- /dev/null
+++ b/fonya-fordprog/README.md
@@ -0,0 +1,9 @@
+**Képzés:** ELTE IK Proginf BSc, Szoftvertervező (B) szakirány (kezdés éve: 2020)  
+**Tárgy neve:** Formális nyelvek és fordítóprogramok alapjai  
+**Tárgy kódja:** IP-18bFNYFPRE/G
+
+A jegyzet témakörönként külön-külön fájlra van bontva.
+
+Linkek:
+ - [Fordítóprogramok jegyzet link](fordítóprogramok/fonyfordprog-fordítóprogramok.pdf)
+ - [Formális nyelvek jegyzet link](formális-nyelvek/fonyfordprog-formális-nyelvek.pdf)
diff --git "a/fonya-fordprog/ford\303\255t\303\263programok/LL1.png" "b/fonya-fordprog/ford\303\255t\303\263programok/LL1.png"
new file mode 100644
index 0000000..fcb7567
Binary files /dev/null and "b/fonya-fordprog/ford\303\255t\303\263programok/LL1.png" differ
diff --git "a/fonya-fordprog/ford\303\255t\303\263programok/LR1.png" "b/fonya-fordprog/ford\303\255t\303\263programok/LR1.png"
new file mode 100644
index 0000000..487dfc7
Binary files /dev/null and "b/fonya-fordprog/ford\303\255t\303\263programok/LR1.png" differ
diff --git "a/fonya-fordprog/ford\303\255t\303\263programok/fonyafordprog-ford\303\255t\303\263programok.pdf" "b/fonya-fordprog/ford\303\255t\303\263programok/fonyafordprog-ford\303\255t\303\263programok.pdf"
new file mode 100644
index 0000000..bed2fe9
Binary files /dev/null and "b/fonya-fordprog/ford\303\255t\303\263programok/fonyafordprog-ford\303\255t\303\263programok.pdf" differ
diff --git "a/fonya-fordprog/ford\303\255t\303\263programok/fonyafordprog-ford\303\255t\303\263programok.tex" "b/fonya-fordprog/ford\303\255t\303\263programok/fonyafordprog-ford\303\255t\303\263programok.tex"
new file mode 100644
index 0000000..488c67a
--- /dev/null
+++ "b/fonya-fordprog/ford\303\255t\303\263programok/fonyafordprog-ford\303\255t\303\263programok.tex"
@@ -0,0 +1,817 @@
+% !TeX spellcheck = hu_HU
+\documentclass[12pt,a4paper]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{cmap}
+\usepackage[T1]{fontenc}
+\usepackage[magyar]{babel}
+\usepackage{amsmath}
+\usepackage{amsfonts}
+\usepackage{amssymb}
+\usepackage{graphicx}
+
+\usepackage{outlines}
+\usepackage{hyperref}
+
+\hyphenpenalty=10000
+
+\begin{document}
+
+\begin{center}
+	\huge
+	Formális nyelvek és fordítóprogramok alapjai\\
+	\vspace{1mm}
+	\LARGE
+	Fordítóprogramok témakör jegyzete\\
+	\vspace{5mm}
+	\large
+	Készült Dévai Gergely előadásai és gyakorlatai alapján\\
+	\vspace{5mm}
+	Sárközi Gergő, 2021-22-2. félév\\
+	Nincsen lektorálva!
+\end{center}
+
+\tableofcontents
+
+\pagebreak
+
+\section{Fordítóprogramok bevezetés}
+
+\begin{outline}
+	\1 Fordítóprogram lényege: magas szintű és gépi kód között áthidal
+	\1 Fordítás (compiler) vs értelmezés (interpreter)
+		\2 Fordítás: optimalizálás, alaposabb ellenőrzés, platformonként
+		\2 Értelmezés: rugalmasabb, csak futási idő van (pl. Python)\\
+		Dinamikus bemenet is futtatható egyszerűen
+	\1 Virtuális gép (JVM, CLR): fordított kód (bájtkód, CLI) értelmezése
+	\1 JIT: bájtkód fordítása gépi kódra futási időben (cél: gyorsítás)
+		\2 Kezdetben csak értelmezés, hot spots-ok keresése
+		\2 Ezután hot spots-ok lefordítása gépi kódra
+			\3 Extra: futási idejű infókat is fel lehet használni fordításkor
+		\2 Miért nem mindent induláskor? $\implies$ lassú indulás
+\end{outline}
+
+\subsection{Fordítás és szerkesztés}
+
+\begin{outline}
+	\1 Statikus könyvtár (.a, .lib):
+		\2 Beépül a futtatható állományba
+	\1 Dinamikus könyvtár (.so, .dll):
+		\2 Pozíciófüggetlen objektumok vannak benne
+		\2 Függőség, hivatkozás egy rendszeren jelen levő könyvtárra
+		\2 Ugyan azt a példányt használja minden processz
+		\2 Csak programkódról van szó, nincs közös memória
+\end{outline}
+
+\pagebreak
+
+\subsection{Fordítóprogramok logikai felépítése}
+
+\begin{outline}
+	\1 Bemenet: forráskód
+	\1 Analízis: lexikális, szintaktikus, szemantikus elemzés (ez a sorrend)
+		\2 Minden hibának ki kell itt derülnie
+		\2 Lexikális elemzés:
+			\3 Kimenet: tokenek (lexikális elemek) sorozata
+			\3 Whitespace-t általában figyelmen kívül hagyjuk
+		\2 Szintaktikus elemzés:
+			\3 Kimenet: szintaxisfa
+			\3 Tokenek belső szerkezetének feltérképezése, ellenőrzése
+			\3 Token: szintaktikus elemzés nyelvtanának terminális szimbóluma
+		\2 Szemantikus elemzés: (statikus szemantika)
+			\3 Kimenet: szintaxisfa attribútumokkal, szimbólumtábla
+				\4 Attribútum példa: milyen típusú egy kifejezés
+				\4 Szimbólumtábla példa: milyen típusú egy változó
+			\3 pl. változó deklarálva volt-e, típushelyes-e minden
+	\1 Szintézis: kódgenerálás, optimalizálás
+		\2 Általában nem egy lépés, hanem transzformációk sorozata
+		\2 Váltják egymást, először valami köztes nyelv, végül tárgykód
+		\2 Kódgenerálás:
+			\3 Nem érdemes egyből gépi kódra fordítani
+			\3 magas szint $\to$ (fordító) $\to$ Assembly $\to$ (assembler) $\to$ gépikód
+		\2 Optimalizálás:
+			\3 Példa: szintaxisfa optimalizálás $\to$ kódgen. $\to$ assembly optim.
+	\1 Kimenet: tárgykód
+\end{outline}
+
+\pagebreak
+
+\section{Lexikális elemzés (scanner / lexer)}
+
+\subsection{Bevezetés}
+
+\begin{outline}
+	\1 Feladat: forrásszöveg elemi egységekre bontása
+	\1 Bemenet: karaktersorozat
+	\1 Kimenet: lexikális elemek (tokenek)
+	\1 Eszközök: reguláris kifejezések, véges determinisztikus automaták
+\end{outline}
+
+\subsection{Whitespace, kommentek}
+
+\begin{outline}
+	\1 Whitespace fel van ismerve, de nem készül belőle token
+	\1 Behúzás-érzékeny nyelvek: számon van tartva, készül belőle behúzás szintet növelő/csökkentő token
+	\1 Kommenteket is felismeri a lexer, ebből sem készül token
+\end{outline}
+
+\subsection{Tokenizálás}
+
+\begin{outline}
+	\1 Egy tokenhez a reguláris kifejezés általában elég egyszerű, hiszen ezek az elemi (legkisebb) egységek.
+	\1 A leghosszabb illeszkedést keressük: addig vesszük a következő karaktert, amíg már semmi nem illeszkedik. Ekkor az előző karaktersorozatra illeszkedő regexek közül vesszük a sorrendben az elsőt.
+		\2 Leghosszabb illeszkedés elve: leghosszabb illeszkedést keressük
+		\2 Prioritás elve: több regex közül a sorrendben az első "nyer"
+		\2 A leghosszabb illeszkedés fontosabb, mint a sorrend
+	\1 Implementáció:
+		\2 Reguláris kifejezést VDA-vá alakítjuk
+		\2 VDA implementáció: elágazásokkal / táblázattal
+\end{outline}
+
+\pagebreak
+
+\subsubsection{Tokenekhez csatolt információk}
+
+\begin{outline}
+	\1 Minden tokenhez: pozíció (első és utolsó karakter: sor és oszlopszám)
+		\2 Hibaüzenetekhez szükséges
+	\1 Azonosítókhoz, literálokhoz: a megadott érték (lásd szemantikus elemzés)
+\end{outline}
+
+\subsubsection{Lexikális hibák}
+
+\begin{outline}
+	\1 Akkor van hiba, ha semmi nem match-elt
+	\1 Egyszerű megoldás: egy karaktert kidobunk (kiírunk hibát), többi karakterrel folytatjuk az elemzést
+	\1 Példa: illegális karakter (karakter nincs a nyelv abécéjében)
+	\1 Példa: lezáratlan string (hiba a sor végén derül ki)
+	\1 Példa: lezáratlan többsoros megjegyzés (fájl végén derül ki)
+\end{outline}
+
+\pagebreak
+
+\section{Szintaktikus elemzés (syntax checker)}
+
+\subsection{Bevezetés}
+
+\begin{outline}
+	\1 Feladat: forrásszöveg szerkezetének felderítése, formai ellenőrzése
+	\1 Bemenet: tokenek
+	\1 Kimenet: szintaxisfa és szintaktikus hibák
+	\1 Eszközök: környezetfüggetlen nyelvtanok, veremautomaták
+\end{outline}
+
+\subsection{Szintaxisfa}
+
+\begin{outline}
+	\1 Levelek balról jobbról olvasva kiadják a bemeneti tokeneket
+	\1 Grammatika alapján jön létre; az szabályozza, hogy mi megengedett
+\end{outline}
+
+\subsection{Nyelvtan elvárt tulajdonságai}
+
+\begin{outline}
+	\1 Redukáltság: nincsenek felesleges nemterminálisok
+	\1 Ciklusmentesség: az baj, ha $A$-ból eljuthatunk $A$-ba anélkül, hogy bármilyen terminálist előállítanánk
+	\1 Egyértelműség: minden szóhoz pontosan egy szintaxisfának kell tartoznia
+		\2 Többféle levezetés szabályos, ez mást jelent!
+\end{outline}
+
+\subsection{Nem egyértelmű szintaxisfa megoldása}
+
+\begin{outline}
+	\1 Példa: nyelvtan számok összeadására (Bonyolítás: szorzást is belevesszük)
+		\2 Helytelen: $E \to \mathbb{N} \;|\; E + E$
+		\2 Helyes: $E \to \mathbb{N} \;|\; E + \mathbb{N}$
+	\1 Operátor precedencia megadása (erre a példa nem tér ki)
+	\1 Operátor asszociativitásának megadása
+\end{outline}
+
+\subsection{Szintaxisfa felépítése}
+
+\begin{outline}
+	\1 Két fő család: felülről lefelé és alulról felfelé
+\end{outline}
+
+\pagebreak
+
+\subsubsection{Felülről lefelé elemzés (pl. ANTLR)}
+
+\begin{outline}
+	\1 Startszimbólumból indulva terminálisok felé haladunk
+	\1 Input feldolgozása: balról jobbra
+	\1 Legbaloldalibb levezetés: több terminális esetén a legbaloldalibb
+	\1 Előreolvasás: következő pár token alapján válasszunk szabályt
+		\2 Egy nyelvtan LL(k) tulajdonságú, ha felülről lefelé elemzés során legfeljebb $k$ token előreolvasásával meghatározható a legbaloldalibb feldolgozatlan nemterminálishoz alkalmazandó nyelvtani szabály
+		\2 Van olyan nyelvtan, amihez nem létezik ilyen $k$, de a programozási nyelvek nyelvtanai nem ilyenek
+	\1 Legyen $\alpha$ egy tetszőleges szimbólumsorozat: terminálisok és nemterminálisok
+	\1 $FIRST_1(\alpha) = \alpha$-ból levezethető szimbólumsorozatok első karakterei
+		\2 $\epsilon$ része ha az üres szó levezethető, továbbá $FIRST_1(\epsilon) = \{\epsilon\}$
+		\2 $\alpha$ egy terminálissal kezdődik $\implies$ az a terminális az eredmény
+	\1 $FOLLOW_1(\alpha)=$ kezdőszimbólumból levezethető szimbólumsorozatokban milyen terminálisok állhatnak $\alpha$ után
+		\2 $\alpha$ a levezethető szimbólumsorozat legvége $\implies$ \# kerül a halmazba
+		\2 Kiszámolása nem triviális a rekurzív szabályok miatt
+	\1 Rekurzív leszállás: LL(1) elemzés egy implementációja
+		\2 LL: Left to right, using Leftmost derivation
+		\2 Legyen minden nemterminális egy függvény és minden szabályalternatíva egy-egy elágazás-ág (hibakezelés külön ágban)
+		\2 Szabály jobboldal: terminálishoz $accept$, nemterminálishoz fv hívás
+			\3 $accept$: tovább olvasás ha next == paraméter, egyébként hiba
+		\2 Elágazás feltételek megírása, kiszámolása:
+			\3 Legyen a szóban forgó szabály: $A \to \alpha$
+			\3 $FIRST_1(\alpha)$ halmaz kiszámolása, ha van benne $\epsilon$, akkor kivesszük és vesszük az uniót a $FOLLOW_1(A)$ halmazzal
+			\3 Ezen elemek a feltételek: $next == x_1 \;||\; next == x_2 \;||\; ...$
+		\2 Tétel: környezetfüggetlen nyelvtan pontosan akkor LL(1) tulajdonságú, ha bármely $A \to \alpha$, $A \to \beta$ szabályokra a fenti feltételek diszjunktak
+		\2 Van verem: a call stack
+		\2 Név eredete: rekurzív nyelvtan esetén rekurzív függvény hívások
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=1\linewidth]{LL1}
+\end{figure}
+
+\begin{outline}
+	\1 Ábra: felülről lefelé elemzés, LL(1), rekurzív leszállás
+\end{outline}
+
+\subsubsection{Alulról felfelé elemzés (pl. Bison)}
+
+\begin{outline}
+	\1 Terminálisokból indulva a startszimbólum felé építjük a fát
+	\1 Input feldolgozása: balról jobbra
+	\1 Legjobboldali levezetés inverzét állítja elő
+	\1 Van olyan nyelvtan, amit ez támogat de a felülről lefelé elemzés nem
+	\1 LR(1) elemzés: Left to right, using Rightmost derivation
+	\1 Léptetés: következő token elhelyezése verem tetején
+	\1 Redukció: veremben lévő szabály jobboldal helyettesítése szabály baloldallal, közben a 	szintaxisfa bővítése
+		\2 Nem feltétlenül csökkenti a verem méretét: $\epsilon$ szabály 1-gyel növeli
+	\1 Egy nyelvtan LR(k) tulajdonságú, ha legfeljebb $k$ token előreolvasásával meghatározható, hogy léptetés vagy redukció jöjjön és redukció esetén a használandó szabály is kiderül
+	\1 LR(1) elemzés implementálása; léptetés vagy redukció eldöntése
+		\2 Előreolvasás és pillanatnyi állapot alapján (tehát táblázat)
+		\2 Verem: tokeneket és állapotokat tárol (nem hagyományos VDA)
+		\2 Kezdő állapot: 0 (nincs hozzárendelt bemenet, csak állapot van)
+		\2 Bemenet lehet: terminális, nemterminális (kivéve $S$), input vége
+		\2 Elfogadás: $S \to ...$ szabály és input vége "találkozása" esetén
+		\2 Táblázat létrehozása nyelvtanból: nem a tananyag része
+		\2 Tétel: környezetfüggetlen nyelvtan pontosan akkor LR(1) tulajdonságú, ha a táblázat konfliktusmentesen kitölthető
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.7\linewidth]{LR1}
+\end{figure}
+
+\begin{outline}
+	\1 Ábra: Alulról felfelé elemzés, LR(1)
+	\2 Oszlopok: bemenet vagy nemterminális
+	\2 Sorok: pillanatnyi állapot
+	\2 Cellák: mit kell tenni és hogyan (nemterminális esetén csak állapot)
+		\3 Léptetés: verembe helyezni a bemenetet és az odaírt számot
+		\3 Redukció: veremben szabály jobboldal helyettesítése baloldallal
+			\4 Új "bemenet": a nemterminális (a szabály baloldal)
+			\4 Új állapot: baloldali nemterminális oszlopából a szám,
+			de előbb pop-olni kell a vermet: ott maradt állapot sora kell
+		\3 Elfogadás: speciális redukció: készen vagyunk
+\end{outline}
+
+\subsubsection{Backtracking (extra, nem az anyag része)}
+
+\begin{outline}
+	\1 Lassú és nem tudjuk meg, hogy hol a hiba: annyit kapunk vissza, hogy sehogy sem sikerült illeszteni a bemenetet
+	\1 Ezen okokból nem használjuk fordítóprogramokra; vannak jobb megoldások
+\end{outline}
+
+\pagebreak
+
+\section{Szemantikus elemzés (semantic analyzer)}
+
+\subsection{Bevezetés}
+
+\begin{outline}
+	\1 Feladat: statikus szemantika (pl. változó deklaráltsága, típusa) ellenőrzése
+	\1 Bemenet: szintaxisfa
+	\1 Kimenet: szintaxisfa attribútumokkal, szimbólumtábla (+hibák)
+	\1 Eszközök: attribútumnyelvtanok
+\end{outline}
+
+\subsection{Feladatok kategóriái}
+
+\begin{outline}
+	\1 Szimbólumtábla
+		\2 Deklarációk feldolgozása
+		\2 Azonosítószimbólumok deklarációhoz kötése
+		\2 Hatókör, láthatóság szabályok ellenőrzése
+			\3 Hatókör: hol létezik
+			\3 Láthatóság: hol érhető el
+	\1 Attribútumnyelvtan
+		\2 Típusellenőrzés, típuslevezetés
+		\2 Típuskonverziók
+	\1 Warning-ok (pl. konstans nullával osztás)
+		\2 Ezzel mi nem foglalkozunk
+\end{outline}
+
+\pagebreak
+
+\subsection{Szimbólumtábla}
+
+\begin{outline}
+	\1 Oszlopai:
+		\2 Név: szöveg
+		\2 Fajta: függvény, paraméter, lokális változó, stb.
+		\2 Típus: $int \to void$, $int$, stb.
+		\2 Deklaráció: pl. 1. sor, 10. oszlop
+		\2 Használat: pl. 3. sor,  10. oszlop, ... (lista)
+	\1 Beszúrás: új deklaráció esetén
+		\2 Beszúrás előtt mindig keresés van: újradeklarálás tiltása
+	\1 Keresés: szimbólum neve alapján kereshetünk
+		\2 Használatát érdemes feljegyezni (pl. refaktorálás miatt)
+	\1 Implementáció veremként:
+		\2 Beszúrás: tetejére ($push$)
+		\2 Keresés: fentről (tetejéről) lefelé, első találatnál megállunk
+	\1 Blokk-index vektor (ez is egy verem)
+		\2 Új blokk esetén elmentjük a szimbólumtábla-verem tetejét ($push$)
+		\2 Blokkból kilépés esetén:
+			\3 Törlés tábla-veremből ($pop$), amíg teteje nem a mentett érték
+			\3 Lementett értéket kitöröljük a blokk-index vektorból ($pop$)
+	\1 Újradeklarálás megtiltása, de egyes elfedések megengedése
+		\2 Újradeklarálás miatti kereséskor nem megyünk végig a szimbólumtáblán
+		\2 Blokk-index teteje által mutattot deklaráció felett (exkluzív) keresünk
+		\2 Üres a blokk-index vektor $\implies$ egész szimbólumtáblában keresünk
+\end{outline}
+
+\pagebreak
+
+\subsection{Típusrendszerek}
+
+\begin{outline}
+	\1 Statikus (fordítási időben történik a típusellenőrzés)
+		\2 Futás időben nem kell típusinformációt tárolni
+			\3 Kivétel: Java instanceof, C++ alosztályok
+		\2 Sikeres fordítás esetén nem lehet futási idejű típushiba
+			\3 Kivétel: fordítás és futás idejű könyvtár verziók eltérnek
+		\2 pl. Ada, C++, Haskell
+	\1 Dinamikus (futási időben történik a típusellenőrzés)
+		\2 Futási időben típusokat is kell tárolni, nem csak értékeket
+		\2 Utasítások végrehajtása előtt típushelyességet ellenőrizni kell
+		\2 Futási időben derülnek ki egyes hibák, cserébe flexibilisebb
+		\2 pl. Lisp, Erlang
+\end{outline}
+
+\subsection{Ki adja meg a típusokat?}
+
+\begin{outline}
+	\1 Programozó adja meg: deklarációk típusozottak
+		\2 Több lehetőség típusellenőrzésre
+		\2 Egyszerűbb fordítóprogram, gyorsabb fordítás
+	\1 Típuskikövetkeztetés, típuslevezetés: deklarációk általában típus nélkül
+		\2 Műveletek alapján fordítóprogram kitalálja a kifejezés típusát
+		\2 Kényelmes programozni, de olvashatóságért érdemes típusozni
+		\2 pl. Haskell
+\end{outline}
+
+\subsection{Típuskonverzió}
+
+\begin{outline}
+	\1 Egy kifejezés típusát változtatja meg
+	\1 Lehet automatikus (implicit) vagy manuális (explicit)
+	\1 Osztályhierarchia miatti típuskonverzió is van (szülő osztály metódusa)
+	\1 Típuskonverzió miatt az érték is megváltozhat (pl. int-ből double)
+\end{outline}
+
+\pagebreak
+
+\subsection{Attribútumnyelvtan}
+
+\begin{outline}
+	\1 Szintaxist leíró nyelvtan szimbólumaihoz attribútumokat rendelünk
+		\2 Szemantikus elemzéshez kell (deklaráltság-, típusellenőrzés)
+		\2 Kódgeneráláshoz kell (literál értéke, maga a kód)
+		\2 Kódoptimalizáció számára is kell
+	\1 Szabályokhoz akciókat (programkódot) rendelünk
+		\2 Szemantikus ellenőrzést végzünk
+		\2 Kiszámoljuk pl. a szabály baloldal típusát a jobboldal típusaiból
+		\2 Azonosító esetén a szimbólumtáblát használjuk:
+			\3 Neve alapján lekérdezzük a szimbólumtáblát
+			\3 Megnézzük, hogy deklarált-e és mi a típusa
+		\2 Szimbólum többször szerepel szabályban: sorszámozzunk
+	\1 Szintetizált attribútum:
+		\2 Szabály bal oldalán állt, amikor kiszámoltuk (bal oldal kap értéket)
+		\2 Alulról felfelé közvetít információt a szintaxisfában
+		\2 pl. kifejezés típusa
+	\1 Kitüntetett szintetizált attribútum: lexikális elemző ad neki értéket
+		\2 Ehhez módosítani kell a lexikális elemzőt (ne csak tokent adjon)
+		\2 pl. azonosító neve, literál értéke
+	\1 Örökölt attribútum (ciklus példával szemléltetve)
+		\2 Start szabályoknál ($S \to ...$) hamisra állítani a jobb oldalt
+		\2 Normális szabályoknál a bal oldal értékét örökli a jobb oldal
+		\2 Ciklus szabály: igazra állítjuk a jobb oldal megfelelő szimbólumát
+		\2 Fentről lefelé terjed az információ a szintaxisfában
+		\2 Bisonban ilyen nincsen
+			\3 Ezt S-attribútumnyelvtannak hívjuk (nincsenek örökölt attribútumok)
+			\3 Örökölt attribútumok nem illeszkednek jól az LR elemzéshez
+			\3 Megoldás: szimbólumtábla használata ilyenkor (nem tananyag)
+	\1 Megszorítások, elvek, szabályok
+		\2 Csak az adott szabály bal és jobb oldalával foglalkozunk
+			\3 Nem olvasunk a fán feljebb vagy lejjebb
+			\3 Ha szükséges, akkor definiálunk szabályokat és segítségükkel egyesével hordozunk információt a szintaxisfa szintjein
+		\2 Egy attribútumértéket csak egy akció határozhat meg
+			\3 Ha több akció is ugyan azt az értéket írja felül, az baj
+	\1 Nem triviális, hogy az akciókat milyen sorrendben futtatjuk
+		\2 Indoklás: ha ez egyik akció felhasználja egy másik akció eredményét...
+	\1 Attribútumok és kód generálás összefüggése
+		\2 Generált kód is lehet egy attribútum
+		\2 Kódgenerálásnál gondolni kell az attribútumok kiszámítási sorrendjére
+\end{outline}
+
+\pagebreak
+
+\section{Assembly}
+
+\subsection{Bevezetés}
+
+\begin{outline}
+	\1 Assembly: alacsony szintű, hardverközeli programozási nyelvek csoportja
+	\1 Assembler: fordítóprogram assembly-ről gépi kódra
+	\1 Mi 32 bites, x86-os architektúrát, NASM szintaxisú assembly-t használunk
+\end{outline}
+
+\subsubsection{C használat (\texttt{extern} függvények)}
+
+\begin{outline}
+	\1 Pár függvény C-ben (\texttt{io.c}) van megírva egyszerűség kedvéért
+		\2 Assembly-ben túl sok időbe tellene megcsinálni
+	\1 Függvények: \texttt{write\_natural}, \texttt{read\_natural},
+	\texttt{write\_boolean}, \texttt{read\_boolean}
+\end{outline}
+
+\subsubsection{Fordítás}
+
+\begin{outline}
+	\1 \begin{verbatim}nasm -felf Xyz.asm && gcc -m32 io.c Xyz.o -o Xyz\end{verbatim}
+	\1 Xyz-t ki kell cserélni valami értelmes névre
+	\1 \texttt{-m32}: 32 bites mód (64 bites OS esetén is)
+\end{outline}
+
+\subsection{Általános információk}
+
+\begin{outline}
+	\1 Komment: ; után
+	\1 Méretek: byte (1), word (2), dword (4)
+	\1 abc|xyz jelentése: két memória/regiszter terület egymás után olvasandó
+		\2 Szám esetén a magasabb helyi érték van bal oldalt (intuitív)
+\end{outline}
+
+\pagebreak
+
+\subsection{Adattárolás}
+
+\subsubsection{Regiszterek}
+
+\begin{outline}
+	\1 Gyors, kis kapacitás, pillanatnyi művelet operandusai itt vannak általában
+	\1 Általános célú regiszterek: eax, ebx, ecx, edx, esi, edi
+	\1 Speciális regiszterek:
+		\2 eip: instruction pointer, következő végrehajtandó utasításra mutat
+		\2 eflags: jelző bitek (pl. aritmetikai művelet során van beállítva)
+	\1 C-ből hívott függvényben csak ezeket szabad módosítani: eax, ecx, edx
+		\2 A tárgyban nekünk az összes kódunk ilyen
+		\2 Ha mégis módosítjuk, vissza kell őket állítani
+		\2 Összes regiszter mentése/visszaállítása: \texttt{pusha}, \texttt{popa}
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.65\linewidth]{regiszterek-szerkezete}
+\end{figure}
+
+\subsubsection{Verem}
+
+\begin{outline}
+	\1 Itt van: fv paraméter, fv visszatérési érték, fv lokális változó (!!!)
+	\1 0 felé nő, ezért így is lehet törölni (pop) belőle:\texttt{add esp,N}
+	\1 esp: stack pointer, verem tetejére mutat
+		\2 Verembe push után csökken az értéke
+	\1 ebp: base pointer; aktív eljáráshoz tartozó adatokra mutat a veremben
+	\1 Műveletek: (mindkét esetben csak 2 vagy 4 bájtos lehet az operandus)
+		\2 \texttt{push <regiszter/memória/konstans>}
+		\2 \texttt{pop <regiszter/memória>}
+	\1 Ha marad benne valami: C program általában segfault-ol
+\end{outline}
+
+\pagebreak
+
+\subsubsection{Statikus memória}
+
+\begin{outline}
+	\1 Kezdőérték nélküli memóriaterület: \texttt{section .bss}
+		\2 42db double: \texttt{a: resd 42}
+	\1 Kezdőértékkel rendelkező memóriaterület: \texttt{section .data}
+		\2 42 kezdőértékkel double: \texttt{a: dd 42}
+		\2 'x' karakter kezdőértékkel bájt: \texttt{x: db 'x'}
+	\1 Memóriahivatkozás: \texttt{dword [a]} vagy \texttt{dword [a+4*ecx]}
+		\2 Mindkét esetben 4 bájtról van szó \texttt{dword} miatt
+		\2 Néha elhagyható a \texttt{dword}: amikor kikövetkeztethető a méret\\
+		(mert pl. egy regiszter a másik operandus)
+\end{outline}
+
+\subsection{Programkód}
+
+\begin{outline}
+	\1 \texttt{section .text} alatt
+	\1 C program main függvénye: \texttt{main} címke; fájl tetején: \texttt{global main}
+		\1 Önálló assembly program esetén: \texttt{main} helyett \texttt{\_start}
+	\1 Fájl tetején: \texttt{extern read\_naural}, stb. (io.c használatához)
+	\1 \texttt{ret}: visszatér a függvényből, az érték: eax regiszter értéke (konvenció)
+\end{outline}
+
+\pagebreak
+
+\subsection{Műveletek}
+
+\subsubsection{Általános tudnivalók}
+
+\begin{outline}
+	\1 Általában legfeljebb 1 memóriahivatkozás megengedett (alap: regiszter)
+	\1 Regiszterből implicit kiderül, hogy hány bájtról van szó
+		\2 Ilyenkor a memóriahivatkozásnál nem kell odaírni
+		\2 De oda kell írni pl. 1 konstans és 1 memóriahivatkozás esetén
+\end{outline}
+
+\subsubsection{Aritmetikai műveletek}
+
+\begin{outline}
+	\1 \texttt{add mihez,mit}
+	\1 \texttt{sub miből,mit}
+	\1 \texttt{inc mit}
+	\1 \texttt{dec mit}
+	\1 \texttt{mul mivel}: edx|eax = eax * <mivel>
+		\2 legyen <mivel> 4 bájtos
+	\1 \texttt{div mivel}: alábbi egész osztást végzi el: edx|eax / <mivel>
+		\2 Eredmény: eax=hányados, edx=maradék
+		\2 Történhet adatvesztés, amikor pl. edx|eax nagy és <mivel>=1
+	\1 Előjeles számok esetén: \texttt{i} prefix, pl. \texttt{imul}
+\end{outline}
+
+\pagebreak
+
+\subsubsection{Összehasonlítás}
+
+\begin{outline}
+	\1 \texttt{cmp mit,mihez}: \texttt{eflags}-be menti az eredményt
+	\1 Felhasználható feltételes ugráshoz, feltételes mozgatáshoz, stb.
+\end{outline}
+
+\begin{table}[h]
+	\centering
+	\begin{tabular}{|c|c|c|c|c|}
+		\hline
+		Jelentés & Szuffix & Kiírva & Kiírva 2 & Szuffix 2 \\
+		\hline
+		mit == mihez & e & equal & & \\
+		\hline
+		mit != mihez & ne & not equal & & \\
+		\hline
+		mit < mihez & b & below & not above equal & nae \\
+		\hline
+		mit >= mihez & nb & not below & above equal & ae \\
+		\hline
+		mit > mihez & a & above & not below equal & nbe \\
+		\hline
+		mit <= mihez & na & not above & below equal & be \\
+		\hline
+	\end{tabular}
+\end{table}
+
+\subsubsection{Ugrás (feltétel nélküli, feltételes ugrás)}
+
+\begin{outline}
+	\1 Címkére szokás ugrani
+	\1 \texttt{jmp hová}: feltétel nélküli ugrás
+	\1 \texttt{j<szuffix> hová}: feltételes ugrás, előtte \texttt{cmp} szükséges
+		\2 \texttt{j<szuffix> near hová}: 1 bájt helyett 4-en tárolja a távolságot
+		\2 Ezt a \texttt{near} változatot használjuk kódgeneráláshoz!
+		\2 Sima \texttt{jmp} 4 bájtot használ, ott nem kell \texttt{near}
+\end{outline}
+
+\subsubsection{Adat mozgatás, másolás (feltétel nélküli, feltételes)}
+
+\begin{outline}
+	\1 Valójában másolás: régi érték úgy marad
+	\1 \texttt{mov hová,honnan}: feltétel nélküli mozgatás
+	\1 \texttt{cmov<szuffix> hová,honnan}: feltételes mozgatás
+\end{outline}
+
+\pagebreak
+
+\subsubsection{Bitműveletek}
+
+\begin{outline}
+	\1 \texttt{and mihez,mit}
+	\1 \texttt{or mihez,mit}
+	\1 \texttt{xor mihez,mit}
+	\1 \texttt{not mit}: ez lehet memóriaterület és regiszter is
+\end{outline}
+
+\subsubsection{Függvény hívás és visszatérés}
+
+\begin{outline}
+	\1 \texttt{call cimke}: "függvény" hívás
+		\2 Következő utasítás címét (\texttt{eip}) beteszi a verembe
+		\2 Az operandusként adott címkéhez ugrik a vezérlés
+	\1 \texttt{ret}: veremből pop (ami az \texttt{eip} volt) és oda ugrik a vezérlés
+	\1 Paraméterátadás:
+		\2 \texttt{call} előtt verembe push-olunk, utána pedig pop-olunk
+		\2 Függvényen belül \texttt{[esp+4]}-től olvasunk a veremből (\texttt{mov}-val)
+			\3 Hiszen \texttt{esp}-nél 4 bájton az \texttt{eip} régi értéke található
+	\1 C függvény hívása:
+		\2 Címke (amihez ugrunk) a függvény neve
+		\2 Paramétereket fordított sorrendben tesszük a verembe, tehát az első paraméter lesz a verem tetején
+			\3 Hogy pl. \texttt{printf} megszámolhassa paramétereinek számát
+		\2 Visszatérési érték: \texttt{eax} regiszterben
+			\3 Nem fér bele: általában memóriába kerül, \texttt{eax}-ben pointer
+\end{outline}
+
+\pagebreak
+
+\subsection{Copy-paste-elhető sablonok}
+
+\subsubsection{Egyágú elágazás}
+
+\begin{verbatim}
+cmp eax,ebx
+jne vege
+... ; Végrehajtva, ha eax == ebx
+vege:\end{verbatim}
+
+\subsubsection{Kétágú elágazás}
+
+\begin{verbatim}
+cmp ebx,ebx
+jne nemegyenlo
+... ; Végrehajtva, ha eax == ebx
+jmp vege
+nemegyenlo:
+... ; Végrehajtva, ha eax != ebx
+vege:\end{verbatim}
+
+\subsubsection{Számláló ciklus}
+
+\begin{verbatim}
+mov ecx,0 ; 10-től számolunk felfelé, ecx a számláló
+eleje:
+cmp ecx,10
+je vege
+...        ; Ciklusmag
+inc ecx
+jmp eleje
+vege:\end{verbatim}
+
+\pagebreak
+
+\section{Kódgenerálás}
+
+\subsection{Bevezetés}
+
+\begin{outline}
+	\1 Feladat: alacsonyabb szintű reprezentációra (végül tárgykódra) alakítás
+	\1 Bemenet: szintaxisfa attribútumokkal, szimbólumtábla
+	\1 Kimenet: tárgykód
+		\2 Gépi kódot generálni követlenül csak nagyon indokolt esetben
+		\2 Jobb alternatíva: LLVM, Assembly, C, Java bájtkód, stb.
+		\2 Transzláció: magas szintű nyelvek közötti fordítás
+	\1 Eszközök: kódgenerálási sémák
+\end{outline}
+
+\subsection{Kódgenerálás attribútumnyelvtannal}
+
+\begin{outline}
+	\1 Eddig típusellenőrzéshez használtunk attribútumnyelvtanokat
+	\1 Most generált kódot is attribútumként kezeljük
+	\1 Szimbólumtáblában label-t (memóriacímkét) tárolunk minden változóhoz
+\end{outline}
+
+\subsection{Generált kód}
+
+\begin{outline}
+	\1 Kifejezés visszatérési értéke: \texttt{eax} regiszterben (pl. szám esetén)
+	\1 Szimbólumtáblában memóriafoglalásokhoz szükséges kód: start szabályban
+		\2 Kezdőérték nélküli változók lesznek (méretük típustól függ)
+\end{outline}
+
+\subsection{Végeredmény}
+
+\begin{verbatim}
+global main
+extern <io.c-ből külső címkék...>
+
+section .bss
+<változók...>
+
+section .text
+main: <programutasítások...>
+      mov eax,0
+      ret\end{verbatim}
+
+\pagebreak
+
+\section{Gyakorlati jegyzet}
+
+\begin{outline}
+	\1 Figyeljünk a megfelelő újsor karakterre: LF kell (CRLF nem jó)
+		\2 Főleg teszt fájlnál jön elő, "Unexpected character: " formában
+\end{outline}
+
+\subsection{\texttt{while.cc}}
+
+\begin{outline}
+	\1 C++ forrásfájl, mi írjuk kézzel, gcc-nek adjuk át
+	\1 A \texttt{while} program belépési pontja is itt található
+	\1 Pár flex/bison dolog itt van implementálva
+	\1 Itt lehet a kitüntetett szintetizált attribútumoknak értéket adni
+\end{outline}
+
+\subsection{\texttt{while.l}}
+
+\begin{outline}
+	\1 Lexikális elemzéshez szükséges, flex-nek adjuk át
+	\1 Token regexek és hozzájuk tartozó C++ kód található itt
+		\2 Nem kötelező a kódban return-t használni
+		\2 Lexikális elemzéshez elég lenne stdio-ra kiírás is
+		\2 Token-ek a \texttt{while.y} fájlban vannak definiálva
+	\1 Regex-ek feldolgozása:
+		\2 Először a leghosszabb illeszkedést keressük meg
+		\2 Ha ez többre is match-el, akkor sorrendben az elsőt vesszük
+		\2 Más esetben nem számít a sorrend
+	\1 Használt függvények:
+		\2 \texttt{YYText()}: mire illeszkedett a regex
+		\2 \texttt{lineno()}: hányadik sorban vagyunk
+			\3 Be kell (be van) kapcsolni: \texttt{\%option yylineno}
+\end{outline}
+
+\pagebreak
+
+\subsection{\texttt{while.y}}
+
+\begin{outline}
+	\1 Szintaktikus és szemantikus elemzéshez szükséges, bison-nak adjuk át
+	\1 Környezetfüggetlen nyelvtan van benne
+		\2 Terminális: nagybetűs
+		\2 Nemterminális: kisbetűs
+		\2 Sorrend akkor számít, ha nem egyértelmű a nyelvtan (ami hiba)
+	\1 Lehetséges hibák, konfliktok:
+		\2 shift/reduce conflicts: nem egyértelmű a nyelv
+	\1 Tokeneket ebben a fájlban definiáljuk
+		\2 Több definíció is kerülhet egy sorba
+		\2 \texttt{\%token ...}: normál token, sorrend nem számít
+		\2 \texttt{\%left ...}: bal asszociatív token
+		\2 \texttt{\%precedence ...}: prefix operátor
+		\2 Ahol számít a sorrend: minél lejjebb, annál erősebb
+	\1 Attribútumok (szemantikus elemzéshez):
+		\2 \texttt{\%token <std::string> T\_ID}: egy kitüntetett szintetizált attr.
+		\2 \texttt{\%token <type> expression}: egy szintetizált attr.
+			\3 Típusok a \texttt{implementation.hh}-ban vannak definiálva (enum)
+		\2 C++ kódban a 2. (jobb oldali) szimbólum értéke \texttt{\$2}, helye \texttt{@2}
+		\2 C++ kódban a bal oldal értéke (írásra): \texttt{\$\$ = ...}
+	\1 Emlékeztető: bison a szabály jobb oldalát cseréli le a bal oldalra
+		\2 Hasonlóan: \texttt{\$\$} értékét jobb oldali értékekből számoljuk (nem fordítva)
+	\1 Emlékeztető: deklarációk nem attribútumokkal vannak típusozva,
+	hanem szimbólumtábla segítségével (ami az \texttt{implementation.hh} része)
+\end{outline}
+
+\pagebreak
+
+\subsection{\texttt{implementation.hh}, \texttt{implementation.cc}}
+
+\begin{outline}
+	\1 Szemantikus elemzéshez szükséges, de csak a gcc-nek adjuk át
+	\1 Típusok itt vannak definiálva (egy enum-ként)
+	\1 Szimbólum tábla itt van definiálva (\texttt{std::map<std::string, type>})
+\end{outline}
+
+\subsection{Assembly integráció, kódgenerálás}
+
+\begin{outline}
+	\1 expression attribútum: régihez hasonlóan type + a generált kód
+	\1 command, commands attr: generált kód
+	\1 szimbólumtábla: címkét is tárol
+	\1 start szabály: stdout-ra kiírjunk az assembly forráskódot
+	\1 Kifejezések eredménye
+		\2 \texttt{natural} eredménye: eax regiszterben
+		\2 \texttt{boolean} eredménye: al regiszterben (1=igaz, 0=hamis)
+	\1 \begin{verbatim}make && ./while MY-TEST.test > test-out.asm && nasm -felf test-out.asm
+	     && gcc -m32 io.c test-out.o -o test-out && ./test-out\end{verbatim}
+\end{outline}
+
+\subsubsection{Új típus létrehozása}
+
+\begin{outline}
+	\1 while.l: típus és literál token létrehozása
+	\1 while.y:
+		\2 start szabály: lefoglalt memória méretét be kell állítani
+		\2 declaration: típus tokenhez
+		\2 expression: literál tokenhez
+		\2 értékadást és érték kiolvasást ki kell egészíteni
+	\1 while.cc: kitüntetett szintetizált attribútumnak (literálnak) értékadás
+	\1 Akár több regiszter is használható az adat tárolására (de bonyolít)
+\end{outline}
+
+\end{document}
diff --git "a/fonya-fordprog/ford\303\255t\303\263programok/regiszterek-szerkezete.png" "b/fonya-fordprog/ford\303\255t\303\263programok/regiszterek-szerkezete.png"
new file mode 100644
index 0000000..46e2b74
Binary files /dev/null and "b/fonya-fordprog/ford\303\255t\303\263programok/regiszterek-szerkezete.png" differ
diff --git "a/fonya-fordprog/form\303\241lis-nyelvek/fonyafordprog-form\303\241lis-nyelvek.pdf" "b/fonya-fordprog/form\303\241lis-nyelvek/fonyafordprog-form\303\241lis-nyelvek.pdf"
new file mode 100644
index 0000000..b3f719f
Binary files /dev/null and "b/fonya-fordprog/form\303\241lis-nyelvek/fonyafordprog-form\303\241lis-nyelvek.pdf" differ
diff --git "a/fonya-fordprog/form\303\241lis-nyelvek/fonyafordprog-form\303\241lis-nyelvek.tex" "b/fonya-fordprog/form\303\241lis-nyelvek/fonyafordprog-form\303\241lis-nyelvek.tex"
new file mode 100644
index 0000000..f2acd87
--- /dev/null
+++ "b/fonya-fordprog/form\303\241lis-nyelvek/fonyafordprog-form\303\241lis-nyelvek.tex"
@@ -0,0 +1,764 @@
+% !TeX spellcheck = hu_HU
+\documentclass[12pt,a4paper]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{cmap}
+\usepackage[T1]{fontenc}
+\usepackage[magyar]{babel}
+\usepackage{amsmath}
+\usepackage{amsfonts}
+\usepackage{amssymb}
+\usepackage{graphicx}
+
+\usepackage{outlines}
+\usepackage{hyperref}
+
+\hyphenpenalty=10000
+
+\newcommand{\gto}{\Rightarrow_G}
+%\newcommand{\gto}{{\implies \atop G}}
+\newcommand{\gtos}{\Rightarrow_G^*}
+\newcommand{\ato}{\Rightarrow_A}
+\newcommand{\atos}{\Rightarrow_A^*}
+
+\begin{document}
+
+\begin{center}
+	\huge
+	Formális nyelvek és fordítóprogramok alapjai\\
+	\vspace{1mm}
+	\LARGE
+	Formális nyelvek témakör jegyzete\\
+	\vspace{5mm}
+	\large
+	Készült Nagy Sára előadásai\\
+	és Dévai Gergely gyakorlatai alapján\\
+	\vspace{5mm}
+	Sárközi Gergő, 2021-22-2. félév\\
+	Nincsen lektorálva!
+\end{center}
+
+\tableofcontents
+
+\pagebreak
+
+\section{Előadás 1: Alapfogalmak és jelölések}
+
+\begin{outline}
+	\1 Két halmaz akkor egyenlő, ha egymásnak részhalmazai.
+	\1 Ábécé: jelek egy nem üres véges halmaza, jele: $V$
+	\1 Betű: ábécé elemei ($a \in V$)
+	\1 Szó: $V$ feletti szó a $V$ ábécé elemeinek véges sorozata (szó=sztring)
+		\2 $u$ szó hossza: $\ell(u)$ \; ($0 \le \ell(u) < \infty$)
+		\2 üres szó: $\epsilon$ \; ($\ell(\epsilon) = 0$)
+	\1 $V^*$: $V$ ábécé feletti szavak halmaza
+		\2 $\epsilon \in V^*$, de $V^+ = V \setminus \{\epsilon\}$
+	\1 Nyelv, formális nyelv: $V^*$ egy bizonyos részhalmaza, jele: $L$
+		\2 Létezik véges és végtelen nyelv
+		\2 Üres szót tartalmazó nyelv: $\{\epsilon\}$
+		\2 Üres nyelv: $\emptyset$
+	\1 Nyelvosztály, nyelvcsalád: nyelvek valamely halmaza
+	\1 Lexikografikus rendezés: először hosszúság szerint, utána ábécé szerint
+		\2 Véges és végtelen nyelveket is el lehet kezdeni felsorolni így
+\end{outline}
+
+\subsection{Szavak műveletei}
+
+\begin{outline}
+	\1 Konkatenáció: szavak egymás után leírása
+		\2 Nincs műveleti jel: csak egymás után leírjuk a szimbólumokat
+		\2 Egységelem: $\epsilon$
+		\2 Asszociatív: $(uv)w=u(vw)$ \; ($u,v,w \in V^*$)
+		\2 $V^*$ zárt a konkatenáció műveletre
+	\1 Hatványozás: szó önmagával vett $n$-szeres konkatenációja
+		\2 $u^0=\epsilon$, $u^1=u$ és ha $n \ge 1$: $u^n=u^{n-1}u$
+	\1 Szó megfordítása: betűk hátulról előre olvasva, jele: $u^{-1}$
+\end{outline}
+
+\subsubsection{Részszó, szó prefix, szó szuffix}
+
+\begin{outline}
+	\1 Részszó: $v$ az $u$ részszava, ha létezik $x,y$ szó, hogy $u=xvy$
+	\1 Szó prefixe: $v$ az $u$ prefixe, ha létezik $w$ szó, hogy $u=vw$
+	\1 Szó szuffixe: $v$ az $u$ szuffixe, ha létezik $w$ szó, hogy $u=wv$
+	\1 "Valódi" jelentése: a teljes szó és az üres szó nem számít bele
+		\2 Azaz $v \ne \epsilon$ és $v \ne u$
+\end{outline}
+
+\subsection{Nyelvek műveletei}
+
+\begin{outline}
+	\1 Reguláris műveletek: unió, konkatenáció, lezárás
+	\1 Két nyelv uniója: ha $L_1,L_2 \subseteq V^*$: $L_1 \cup L_2 = \{u \in V^* \;|\; u \in L_1 \lor u \in L_2\}$
+		\2 Ha nem mindkettő $V^*$ feletti: ábécé unióját is vesszük
+		\2 Kommutatív, asszociatív, egységelemes ($\emptyset$)
+	\1 Két nyelv metszete: $L_1 \cap L_2 = \{u \in V^* \;|\; u \in L_1 \wedge u \in L_2\}$
+	\1 Egy nyelv komplementere egy ábécére vonatkozóan: $\overline{L} = V^* \setminus L$
+	\1 Egy nyelv tükörképe: $L^{-1} = \{u \in V^* \;|\; u^{-1} \in L \}$
+	\1 Két nyelv konkatenációja: $L_1 L_2 = \{uv \;|\; u \in L_1 \wedge v \in L_2\}$
+		\2 Gyakorlatilag szorzat
+		\2 Asszociatív, egységelemes ($\{\epsilon\}$)
+		\2 Van nullelem: $\emptyset L = \emptyset = L \emptyset$
+	\1 Nyelv hatványozása: ismételt konkatenáció önmagával
+		\2 $L^0 = \{\epsilon\}$, $L^1=L$ és ha $n \ge 1$: $L^n=L^{n-1}L$
+		\2 $\emptyset^0 = \{\epsilon\}$ \; ($\emptyset$ minden más hatványa önmaga)
+	\1 Nyelv lezártja (iteráltja): $L^*=L^0 \cup L^1 \cup L^2 \cup ...$
+		\2 $L^+ = \bigcup\limits_{i \ge 1} L^i$ \; ($\epsilon \in L^+ \Leftrightarrow \epsilon \in L$)
+\end{outline}
+
+\pagebreak
+
+\section{Előadás 2: grammatika}
+
+\begin{outline}
+	\1 Nyelv megadható szabályrendszerrel (de nem mindegyik)
+	\1 Grammatika (nyelvtan): $G=(N,T,P,S)$
+		\2 $N$: nemterminális ábécé (szimbólumok, nagybetűsek)
+		\2 $T$: terminálisok ábécéje (bemeneti szöveg ábécéje, kisbetűsek)
+		\2 $P$: átírási szabályok véges halmaza
+		\2 $S$: kezdőszimbólum ($S \in N$)
+		\2 $N$ és $T$ diszjunkt halmazok
+	\1 Átírási szabályok 
+		\2 $p \to q$ alakúak, ahol $p \in (N \cup T)^*N(N \cup T)^*$ és $q \in (N \cup T)^*$
+			\3 Bal oldal tartalmaz min. 1 nemterminális szimbólumot
+			\3 Jobb oldal lehet üres
+		\2 Mondatforma: $(N \cup T)^*$ (vegyes karakterek)
+			\3 Ha nem vegyes, akkor mondatforma is, de szó is
+\end{outline}
+
+\subsection{Levezetés}
+
+\begin{outline}
+	\1 $v$ közvetlen levezethető $u$-ból ($u \gto v$), ha: \;\; ($u,v \in (N \cup T)^*$)
+		\2 Létezik $u_1,u_2 \in (N \cup T)^*$ és $x \to y \in P$
+		\2 Hogy: $u=u_1 \, x \, u_2$ és $v=u_1 \, y \, u_2$
+	\1 $v$ közvetetten levezethető $u$-ból ($u \gtos v$), ha: \;\; ($u,v \in (N \cup T)^*$)
+		\2 Létezik $k \in \mathbb{N}$ és $x_0,...,x_k \in (N \cup T)^*$
+		\2 Hogy: $u=x_0$ és $v = x_k$ és $\forall i \in [0,k-1]: x_i \gto x_{i+1}$
+	\1 Grammatika által generált nyelv
+		\2 Minden olyan szó, ami (közvetetten) levezethető $S$-ből
+		\2 $L(G) = \{u \in T^* \; | \; S \gtos u \}$
+	\1 Példa: $G=(\{S,A,B\}, \{a,b\}, P, S)$
+		\2 $P=\{S \to ASB,\; S \to AB,\; AB \to BA,\; A \to a,\; B \to b \}$
+		\2 $L(G) = \{u \in \{a,b\}* \;|\; \ell_a(u) = \ell_b(u) \ge 1 \}$
+		\2 Példa: $S \gtos A^nB^n \gtos A^{n-1}BAB^{n-1} \gtos BA^nB^{n-1} \gtos ba^nb^{n-1}$
+\end{outline}
+
+\pagebreak
+
+\subsection{Chomsky féle grammatika típusok}
+
+\begin{outline}
+	\1 A $G=(N,T,P,S)$ grammatikát $P$ alapján lehet osztályozni
+	\1 $i=0$ típus: nincs korlátozás (azaz ennyi: grammatikával megadható)
+	\1 $i=1$ típus, környezetfüggő: $P$ minden szabálya $u_1Au_2 \to u_1vu_2$ alakú,\\
+	ahol $u_1,u_2,v \in (N \cup T)^*$, $A \in N$ és $v \ne \epsilon$,\\
+	kivéve az $S \to \epsilon$ alakú szabály (Korlátozott $\epsilon$ szabály, KES), de ekkor $S$ nem fordul elő egyetlen szabály jobboldalán sem.
+	\1 $i=2$ típus, környezetfüggetlen: $P$ minden szabálya $A \to v$ alakú,\\
+	ahol $A \in N, v \in (N \cup T)^*$
+	\1 $i=3$ típus, reguláris grammatika: $P$ minden szabálya\\
+	vagy $A \to uB$ vagy $A \to u$ alakú, ahol $A,B \in N$ és $u \in T^*$
+	\1 Jelölje $\mathcal{G}_i$ az $i$ típusú grammatikák halmazát
+		\2 $\mathcal{G}_i \subseteq \mathcal{G}_0$ ahol $i \in \{1,2,3\}$
+		\2 $\mathcal{G}_3 \subseteq \mathcal{G}_2 \not \subseteq \mathcal{G}_1 \subseteq \mathcal{G}_0$
+			\3 Hiányzó tartalmazás oka: $\epsilon$-nal kapcsolatos kikötések
+			\3 Epszilon mentes grammatika esetén van tartalmazás ott is
+	\1 Alábbi táblázat sorai egymásba alakítható grammatikák
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=1\linewidth]{grammatika-típusok}
+\end{figure}
+
+\pagebreak
+
+\subsubsection{Grammatika típusuk implementálási igényei}
+
+\begin{outline}
+	\1 3-as típusú grammatika verem nélkül is implementálható
+	\1 2-es nyelvcsaládhoz már kell 1 verem
+	\1 Két veremmel már bármi lehetséges (0-as nyelvcsalád)
+\end{outline}
+
+\subsection{Példa grammatika típusára}
+
+\begin{outline}
+	\1 Kérdés $G=(\{S',S,A,B\}, \{a,b\}, P, S')$ grammatika típusa
+	\1 $P = \begin{cases}
+	S' \to \epsilon & \text{KES}\\
+	S' \to S & \text{0,1,2,3 típusú szabály}\\
+	S \to ASB & \text{0,1,2 típusú szabály}\\
+	S \to AB & \text{0,1,2 típusú szabály}\\
+	AB \to BA & \text{0 típusú szabály (TODO miért nem 1?)}\\
+	A \to a & \text{0,1,2,3 típusú szabály}\\
+	B \to b & \text{0,1,2,3 típusú szabály}
+	\end{cases}$
+	\1 Tehát $G$ grammatika 0-s típusú, $G_1 \in \mathcal{G}_0$
+\end{outline}
+
+\subsection{Nyelvtanok ekvivalenciája}
+
+\begin{outline}
+	\1 $G_1$ és $G_2$ ekvivalensek, ha $L(G_1) = L(G_2)$
+	\1 Gyengén ekvivalensek, ha $L(G_1) \setminus \{\epsilon\} = L(G_2) \setminus \{\epsilon\}$
+\end{outline}
+
+\subsection{Nyelvek típusai}
+
+\begin{outline}
+	\1 Egy $L$ nyelv $i$ típusú, ha $\exists$ $i$-típusú grammatika, ami generálja
+	\1 Nyelvcsalád: $\mathcal{L}_i$ jelöli az $i$-típusú nyelvek halmazát
+	\1 Chomsky féle hierarchia: $\mathcal{L}_3 \subset \mathcal{L}_2 \subset \mathcal{L}_1 \subset \mathcal{L}_0$
+\end{outline}
+
+\subsection{Kényelmi jelölés}
+
+\begin{outline}
+	\1 $S \to A \;|\; B$ jelentése: két szabály, $S \to A$ és $S \to B$
+\end{outline}
+
+\subsection{Bizonyítások}
+
+\begin{outline}
+	\1 Indukcióval
+\end{outline}
+
+\pagebreak
+
+\section{Előadás 3: reguláris műveletek és nyelvek}
+
+\begin{outline}
+	\1 Nyelvtani transzformáció: eljárás, ami $G$-ből $G'$-t csinál
+		\2 Ekvivalens transzformáció, ha $L(G) = L(G')$
+\end{outline}
+
+\subsection{$\epsilon$-mentesítés}
+
+\begin{outline}
+	\1 Tétel:
+		\2 $G=(N,T,P,S)$ legyen környezetfüggetlen (2-es típusú)
+		\2 Csinálható vele ekvivalens $G'=(N',T,P',S')$
+			\3 ami szintén környezetfüggetlen
+			\3 amiben nincs $A \to \epsilon$ alakú szabály, kivéve, ha $\epsilon \in L(G)$, ekkor $S' \to \epsilon \in P'$, de ekkor $S'$ nem szerepelhet szabály jobboldalán
+	\1 Eljárás:
+		\2 Első lépés: mely nemterminálisokból vezethető le az $\epsilon$?
+			\3 $H = \{A \in N \;|\; A \gtos \epsilon \} = \;?$
+			\3 $H_1 = \{A \in N \;|\; \exists A \to \epsilon \in P\}$
+			\3 $H_{i+1} = H_i \cup \{A \in N \;|\; \exists A \to w \in P \wedge w \in H_i^*\}$
+			\3 $H_1 \subset H_2 \subset ... H_k = H_{k+1} \implies H=H_k$
+			\3 Nemterminálisok halmaza véges, tehát az eljárás véges
+			\3 Belátható: $\epsilon \in L(G) \Leftrightarrow S \in H$
+		\2 Második lépés, $S \notin H$ esetén: $A \to v' \in P'$ akkor és csak akkor\\
+		ha $v' \ne \epsilon$ és ha $\exists A \to v \in P$, hogy $v$-ből $v'$-t úgy kapunk,\\
+		hogy elhagyunk nulla vagy több $H$-beli nemterminálist $v$-ből
+		\2 Második lépés, $S \in H$ esetén:
+			\3 Előbb felsorolt szabályok közül az összes
+			\3 Új kezdőszimbólum: $S'$ és $S' \notin N$
+			\3 Két extra szabály: $S' \to \epsilon$ és $S' \to S$
+\end{outline}
+
+\pagebreak
+
+\subsection{Nyelvosztályok zártsága a reguláris műveletekre}
+
+\begin{outline}
+	\1 Tétel: a $\mathcal{L}_{0..3}$ nyelvosztályok mindegyike zárt a reguláris műveletekre
+	\1 Emlékeztető: reguláris műveletek: unió, konkatenáció, lezárás
+\end{outline}
+
+\subsection{Grammatikákon végzett reguláris műveletek}
+
+\subsubsection{Unió, $\mathcal{G}_{0,2,3}$ típusú nyelvek esetén}
+
+\begin{outline}
+	\1 Legyen $G=(N,T,P,S)$ és $G'=(N',T,P',S')$ azonos típusúak
+	\1 Legyen $N \cap N' = \emptyset$ és $S_0$ új szimbólum, $S_0 \notin (N \cup N')$
+	\1 $G_\cup = (N \cup N' \cup \{S_0\} ,\; T ,\; P \cup P' \cup \{S_0 \to S, S_0 \to S'\} ,\; S_0)$
+	\1 Ekkor $G_\cup$ típusa megegyzik $G,G'$ típusával és $L(G) \cup L(G') = L(G_\cup)$
+\end{outline}
+
+\subsubsection{Unió, $\mathcal{G}_1$ típusú nyelvek esetén}
+
+\begin{outline}
+	\1 Ha $\epsilon \in L(G) \cup L(G')$, akkor az előző $G_\cup$-ban nem teljesül a KES
+	\1 $G_\cup$ készítésekor vegyük ki $P$-ből és $P'$-ből a $S\to\epsilon$, $S'\to\epsilon$ szabályokat
+	\1 $G_\cup$ kezdőszimbóluma legyen az új $S_1$ szimbólum
+	\1 $G_\cup$ szabályai közé vegyük be az alábbiakat: $S_1\to\epsilon$, $S_1\to S_0$
+\end{outline}
+
+\subsubsection{Konkatenáció, $\mathcal{G}_3$ típusú nyelvek esetén}
+
+\begin{outline}
+	\1 $P$-ből csinálunk $P_1$-et: $A \to u$ alakúakat lecseréljük $A \to uS'$-re
+	\1 $G_C = (N \cup N' ,\; T ,\; P_1 \cup P' ,\; S)$ és $G_C \in \mathcal{G}_3$ és $L(G_C) = L(G)L(G')$
+\end{outline}
+
+\subsubsection{Lezárt, $\mathcal{G}_3$ típusú nyelvek esetén}
+
+\begin{outline}
+	\1 Legyen $S_0$ új szimbólum ($S_0 \notin N$)
+	\1 $P$-ből csinálunk $P_1$-et: $A \to u$ alakúakat lecseréljük $A \to uS_0$-ra
+	\1 $G_* = (N \cup \{S_0\} ,\; T ,\; P_1 \cup P \cup \{S_0 \to \epsilon, S_0 \to S\} ,\; S_0)$
+	\1 $G_* \in \mathcal{G}_3$ és $L(G_*) = L^*$
+\end{outline}
+
+\pagebreak
+
+\subsection{3-as nyelvcsalád leírásai}
+
+\begin{outline}
+	\1 $\mathcal{G}_3$ nyelvei leírhatóak:
+		\2 3-as típusú grammatikával
+		\2 reguláris kifejezéssel
+		\2 véges determinisztikus automatával
+		\2 véges nemdeterminisztikus automatával
+	\1 Bebizonyítható: $\mathcal{L}_3=\mathcal{L}_{reg}=\mathcal{L}_{VDA}=\mathcal{L}_{VNDA}$
+\end{outline}
+
+\subsection{Reguláris nyelvek}
+
+\begin{outline}
+	\1 Rekurzív definíció:
+		\2 Elemi nyelvek: $\emptyset$, $\{\epsilon\}$ és $\{a\}$, ahol $a$ egy tetszőleges betű
+		\2 Reguláris nyelv: elemi nyelvekből reguláris műveletekkel létrehozható
+		\2 Nincs más reguláris nyelv
+	\1 Tétel: $\mathcal{L}_{reg} \subseteq \mathcal{L}_3$, bizonyítás:
+		\2 Elemi nyelvekhez megadható $3$-as típusú grammatika:\\
+		$G=(\{S\}, \{a\}, \{S \to aS\},
+		S)$, $G=(\{S\}, \{a\}, \{S \to \epsilon\}, S)$,\\
+		$G=(\{S\}, \{a\}, \{S \to a\}, S)$
+		\2 $\mathcal{L}_3$ zárt a reguláris műveletekre
+		\2 Reguláris nyelv def alapján készíthető azonos 3-as nyelv is
+\end{outline}
+
+\subsection{Reguláris kifejezések}
+
+\begin{outline}
+	\1 Definíció:
+		\2 Elemi reguláris kifejezések: $\emptyset$, $\epsilon$, $a$, ahol $a$ egy tetszőleges betű
+		\2 Ha $R_1$ és $R_2$ reguláris kifejezések, akkor az alábbiak is:\\
+	$(R_1 | R_2)$ \;,\; ($R_1R_2$) \;,\; $(R)^*$
+		\2 A reguláris kifejezések halmaza a legszűkebb halmaz, amire a felső két pont teljesül.
+	\1 Műveletek prioritása csökkenő sorrendben: lezárás, konkatenáció, unió
+		\2 A zárójelek ennek megfelelően elhagyhatók
+\end{outline}
+
+\pagebreak
+
+\subsection{Reguláris kifejezés gyakorlati jegyzet}
+
+\begin{outline}
+	\1 $[a-9]$: ha 9 előbb van, akkor üres
+	\1 $.$ (pont) az bármi, kivéve $\backslash n$, de $[\textasciicircum a]$ match-el $\backslash n$-re
+	\1 Be lett vezetve: $a\{5\}$ (de min, max, tól-ig változatai nem)
+	\1 Escaping: " közé, vagy $\backslash$
+	\1 Üresség: "" (kettő ") \;\; (azaz $a? \equiv ""|a$)
+	\1 Halmazban ($[...]$) escape-elni kell a $-$ karaktert, de mást nem
+\end{outline}
+
+\subsection{3-as típusú grammatikák normál formája}
+
+\begin{outline}
+	\1 Tétel: minden $3$-as típusú nyelv generálható ilyen szabályokkal:
+		\2 $A \to aB$, ahol $A,B \in N$ és $a \in T$
+		\2 $A \to \epsilon$ ahol $A \in N$
+	\1 Ez a normál forma
+	\1 Ebből könnyen készíthető automata
+\end{outline}
+
+\pagebreak
+
+\subsubsection{Normál formára alakítás algoritmusa}
+
+\begin{outline}
+	\1 $G=(N,T,P,S) \to G'=(N',T,P',S)$
+		\2 $G$ 3-as típusú grammatika
+		\2 $G'$ 3-as normál formájú grammatika
+	\1 Hosszredukció
+		\2 $A \to a_1...a_kB$ alakú szabályok helyett (ahol $k \ge 2$, $B$ lehet $\epsilon$ is)
+		\2 $A \to a_1Z_1$ ahol $Z_1 \notin N$ és $Z_1 \to A_2Z_2$ ahol $Z_2 \notin (N \cup Z_1)$, stb.
+		\2 Azaz $Z_k$ mindig egy új nemterminális
+		\2 $Z_{k-1} \to a_kB$
+	\1 Befejező szabályok átalakítása
+		\2 Legyen $E$ egy minden szabályra közös új nemterminális
+		\2 $A \to a$ alakú szabályok helyett (ahol $a \in T$ és $A \in N$)\\
+		legyen $P'$ része: $A \to aE$ és $E \to \epsilon$
+	\1 Láncmentesítés
+		\2 $A \to B$ alakú szabályok helyettesítése
+		\2 Ismert módszerrel meghatározzuk: $H(A) = \{B \in N \;|\; A \gtos B \}$
+			\3 $H_1(A) = \{A\}$
+			\3 $H_{i+1}(A)=H_i(A) \cup \{B \in N \;|\; \exists C \in H_i(A) \wedge C \to B \in P\}$
+		\2 Majd $P'$-be felvesszük az $A \to X$ szabályokat,\\
+		ha $\exists B \in H(A)$, hogy $B \to X \in P$ ahol $X \in (T \cup N)^* \setminus N$
+			\3 Azaz ahol $X \in (T \cup N)^*$ és nem csak egyetlen nemterminális
+\end{outline}
+
+\pagebreak
+
+\section{Előadás 4: véges (nem) determinisztikus automaták}
+
+\subsection{Véges determinisztikus automata (VDA)}
+
+\begin{outline}
+	\1 Definíció: $A=(Q,T,\delta, q_0, F)$ a VDA, ahol
+		\2 $Q$: állapotok nemüres VÉGES halmaza
+		\2 $T$: input szimbólumok ábécéje (véges, nemüres)
+		\2 $\delta$: $Q \times T \to Q$ leképezés: állapot-átmenti függvény
+			\3 Determinisztikus, egyértelmű
+			\3 Minden $q,a \in Q \times T$ párra értelmezett (különben parciális)
+			\3 Érdemes táblázattal megadni: bemenetek az oszlopok
+		\2 $q_0 \in Q$: kezdőállapot
+		\2 $F \subseteq Q$: elfogadóállapotok (lehet üres)
+			\3 Ha nem ilyen állapotnál fogy el a bemenet, akkor rossz szó
+	\1 Irányított gráffal megadható: csúcspont az állapot, $\delta$ alapján élek
+		\2 Kezdőállapot jelölése: semmiből induló nyíl vezet bele
+		\2 Elfogadóállapotok ($F$) jelölése: dupla karika
+	\1 Az egész automata megadható $\delta$-t leíró táblázattal, plusz két extra:
+		\2 Befelé nyíl a kezdőállapotnál
+		\2 Kifelé nyíl az elfogadóállapotoknál
+	\1 Beolvasáskor elég a bemenet (szalag) és 1 változó (aktuális állapot)
+		\2 Azaz itt még nincs verem
+	\1 Alternatív jelölés állapot-átmenetekre: $\delta(q, a) = p$ helyett $qa \to p$
+	\1 Konfiguráció: aktuális állapot és a maradék bemenet
+	\1 Automata mindig terminál, mert a bemenet véges
+	\1 Gyakorlaton konvenció: betűvel nem lehet lépni $\implies$ a betűvel a  hibaállapota jutunk
+		\2 Hibaállapot: onnan nem mehetünk másikba és nem elfogadó állapot
+	\1 Gyakorlat: nem muszáj az állapotokat elnevezni
+\end{outline}
+
+\pagebreak
+
+\subsection{Redukció}
+
+\subsubsection{Közvetlen redukció}
+
+\begin{outline}
+	\1 Legyen $A=(Q,T,\delta,Q_0,F)$ egy véges automata
+	\1 $A$ az $u \in QT^*$ konfigurációt a $v \in QT^*$ konfigurációra redukálja közvetlenül...
+		\2 Jelölés: $u \ato v$
+	\1 ... ha létezik $qa \to p$ szabály (azaz $\delta(q,a)=p$)
+	\1 ... és ha $\exists w \in T^*: u = qaw \wedge v = pw$
+\end{outline}
+
+\subsubsection{Általános redukció}
+
+\begin{outline}
+	\1 Legyen $A=(Q,T,\delta,Q_0,F)$ egy véges automata
+	\1 $A$ az $u \in QT^*$ konfigurációt a $v \in QT^*$ konfigurációra redukálja...
+		\2 Jelölés: $u \atos v$
+	\1 ... ha $u = v$ vagy $\exists z \in QT^*: u \atos z \wedge z \ato v$
+\end{outline}
+
+\subsection{Automata által elfogadott nyelv}
+
+\begin{outline}
+	\1 Legyen $A=(Q,T,\delta,q_0,F)$
+	\1 $A$ által elfogadott nyelv: $L(A) = \{u \in T^* \;|\; \exists p \in F: q_0 u \atos p \}$
+	\1 VNDA esetén: $q_0 \in Q_0$ a halmaz definícióban
+\end{outline}
+
+\pagebreak
+
+\subsection{Véges nemdeterminisztikus automata (VNDA)}
+
+\begin{outline}
+	\1 Determinisztikus autotává lehet alakítani (de annak általánosítása is)
+	\1 Különbség: $q_0 \in Q$ helyett $Q_0 \subseteq Q$
+	\1 Különbség: $\delta : Q \times T \to Q$ helyett $\delta: Q \times T \to \mathcal{P}(Q)$
+		\2 $\mathcal{P}(Q)$ jelentése: $Q$ részhalmazainak a halmaza (azaz $Q$ hatványhalmaza)
+		\2 Azaz $\mathcal{P}(Q)$ az a $Q$ hatványhalmaza, ami egy véges halmaz
+		\2 $Q$ hatványhalmazába képez, ez egy véges halmaz
+		\2 Táblázat celláiban lehet 0, 1, vagy több állapot is
+	\1 Egy szó akkor jó, ha létezik olyan lefutás, amikor el van fogadva
+		\2 Azaz ha nem determinisztikus esetben "rossz" döntést hoztunk, de más döntés esetén jó lett volna a szó, akkor a szó az jó
+	\1 Redukciók, elfogadott nyelv definíció gyakorlatilag megegyezik
+\end{outline}
+
+\subsection{3-as típus nyelvek kapcsolata véges automatákkal}
+
+\begin{outline}
+	\1 Tétel: $\mathcal{L}_3 \subseteq \mathcal{L}_{VNDA}$ és $\mathcal{L}_{VNDA} \subseteq \mathcal{L}_3$
+	\1 Bizonyítás: $L \in \mathcal{L}_3$ megadása $A=(Q,T,\delta,Q_0,F)$ VNDA-val
+		\2 Tudjuk, hogy $L$ megadható $G=(N,T,P,S) \in \mathcal{G}_3$ grammatikával
+		\2 Minden nemterminális legyen egy állapot: $Q = \{q_X \;|\; X \in N\}$
+		\2 Kezdőállapot: $Q_0 = q_S = \{S\}$
+		\2 Legyen $\delta(q_a,a) = q_B \Leftrightarrow (A \to aB) \in P$
+		\2 Legyen $q_A \in F \Leftrightarrow (A \to \epsilon) \in P$
+		\2 Megjegyzés: eredmény nem feltétlenül determinisztikus automata
+		\2 Megjegyzés: $S \gtos u \Leftrightarrow q_S \atos u$
+	\1 A másik irány bizonyítása hasonló
+\end{outline}
+
+\pagebreak
+
+\subsection{VNDA-ból VDA}
+
+\begin{outline}
+	\1 Tétel: $\mathcal{L}_{VNDA} \subseteq \mathcal{L}_{VDA}$
+	\1 Másik irány triviális definíció alapján	
+\end{outline}
+
+\subsubsection{Módszer VNDA-ból VDA konstruálásra}
+
+\begin{outline}
+	\1 Alapötlet: legyenek az állapotok maguk is halmazok
+		\2 Üres halmaz is egy állapot
+	\1 Legyen $Q' = \mathcal{P}(Q)$, azaz $Q$ részhalmazainak a halmaza (hatványhalmaz)
+	\1 Legyen $\delta' : Q' \times T \to Q'$ így definiálva:
+		\2 $\delta' (q',a) = \bigcup_{q \in q'} \delta(q,a)$ ahol $q' \in Q'$ és $a \in T$
+	\1 Legyen $q_0' = Q_0$
+	\1 Legyen $F' = \{q' \in Q' \;|\; q' \cap F \ne \emptyset\}$
+	\1 Bizonyítás: $L(A) \subseteq L(A')$
+		\2 Lemma 1: $\forall q,p \in Q; q' \in Q'; u,v \in T^*$ esetén\\
+		ha $qu \atos pv \wedge q \in q'$ akkor $\exists p' \in Q': q'u \atos p'v \wedge p \in p'$
+		\2 Maradék bizonyítás: fny\_4.pdf, 28. oldal
+	\1 Bizonyítás: $L(A') \subseteq L(A)$
+		\2 fny\_4.pdf, 29. oldal
+\end{outline}
+
+\pagebreak
+
+\subsection{Kleene tétele: $\mathcal{L}_3 = \mathcal{L}_{reg}$}
+
+\begin{outline}
+	\1 Bizonyítás vázlat:
+		\2 $\mathcal{L}_{reg} \subseteq \mathcal{L}_3$ (már beláttuk)
+		\2 $\mathcal{L}_3 = \mathcal{L}_{VDA}$ (már beláttuk)
+		\2 $\mathcal{L}_{VDA} \subseteq \mathcal{L}_{reg}$
+\end{outline}
+
+\subsubsection{$\mathcal{L}_{VDA} \subseteq \mathcal{L}_{reg}$ bizonyítása}
+
+\begin{outline}
+	\1 Legyen $A$ egy $n$ állapotú VDA: $Q=\{q_1, q_2, ..., q_n\}$ és $q_1$ a kezdőállapot
+	\1 $q_i u \atos q_j$ redukció
+		\2 Érinti a $q_m$ állapotot, ha $q_m$ egy közbülső lépés része
+		\2 $k$-megszorított, ha csak $q_1$ és $q_k$ közötti állapotokat érint\\
+		($i$ és $j$ nincs megszorítva, csak a közbülső lépések)
+	\1 Milyen szavakba lehet eljutni $k$ megszorítással?
+		\2 $0 \le k \le n$ és $1 \le i,j \le n$
+		\2 $E_{i,i}^0 = \{\epsilon\} \cup \{ a \in T \;|\; \exists q_i a \to q_i \}$
+		\2 $E_{i,j}^0 = \{a \in T \;|\; \exists q_i a \to q_j \}$ ahol $i \ne j$
+		\2 $E_{i,j}^k = \{u \in T^* \;|\; \exists q_i u	\atos q_j \text{ k-megszorított redukció} \}$
+		\2 $E_{i,j}^k = E_{i,j}^{k-1} \; \cup \; E_{i,k}^{k-1} \; (E_{k,k}^{k-1})^* \; E_{k,j}^{k-1}$
+	\1 Automata által elfogadott állapotok: $L(A) = \bigcup_{i \in I} E_{1,i}^n$
+		\2 Ahol $I$ az elfogadó állapotok indexekei
+		\2 Ez csak reguláris műveleteket használ: unió, konkatenáció, lezárás
+\end{outline}
+
+\pagebreak
+
+\section{Előadás 5: minimális automata}
+
+\subsection{Minimális véges determinisztikus automata}
+
+\begin{outline}
+	\1 Egy $A$ VDA minimális, ha állapotainak száma minimális: nincs olyan $A'$ VDA, hogy $L(A)=L(A')$, de $A'$ állapotainak száma kevesebb
+\end{outline}
+
+\subsubsection{$L \in \mathcal{L}_{reg}$-et felismerő minimális VDA izomorfizmusig egyértelmű}
+
+\begin{outline}
+	\1 $L$ reguláris nyelvet felismerő minimális VDA: izomorfizmus erejéig egyértelmű
+	\1 Bizonyítás lépései:
+		\2 Automata összefüggővé tétele: nem elérhető állapotok elhagyása
+		\2 Ekvivalens állapotok meghatározása
+	\1 Elkészített véges automata: $A'=(Q',T,\delta',q_0',F')$
+		\2 Az állapotok partíciókra cseréljük le (partíciókról később)
+		\2 $Q'=B_i \text{ partíciók}$
+		\2 $q_0' = q_0 \text{-t tartalamzó partíció}$
+		\2 $F'=F \text{-ből keletkezett partíciók}$
+		\2 $\delta'(B_i,a) = B_j \impliedby \delta(q,a) = p \wedge q \in B_i \wedge p \in B_j$
+\end{outline}
+
+\subsubsection{Összefüggő VDA}
+
+\begin{outline}
+	\1 $A=(Q,T,\delta,q_0,F)$ VDA $q$ állapota elérhető, ha $\exists u \in T^*: q_0 u \atos q$
+	\1 Egy VDA összefüggő, ha minden állapota elérhető $q_0$-ból
+	\1 Elérhető állapotok meghatározása:
+		\2 $H_0 = \{q_0\}$
+		\2 $H_{i+1} = H_i \cup \{r \in Q \;|\; \delta(q,a) = r; q \in H_i; a \in T\}$
+		\2 $H=H_k$, ahol $H_k = H_{k+1}$
+	\1 Tehát a $Q \setminus H$ állapotok elhagyhatóak: nem elérhetőek
+\end{outline}
+
+\pagebreak
+
+\subsubsection{Ekvivalens állapotok meghatározása}
+
+\begin{outline}
+	\1 $q$ és $p$ ekvivalens ($q \sim p$), ha minden szóra egyformán működnek
+		\2 Azaz: $\forall u \in T^*: (qu \atos r \wedge pu \atos r') \implies (r \in F \Leftrightarrow r' \in F)$
+	\1 Állítás: $(q \sim p \wedge qa \to s \wedge pa \to t) \implies s \sim t$
+		\2 Azaz ha két ekvivalens állapotból azonos betűvel léptünk, akkor ekvivalens állapotokba jutunk.
+	\1 $q$ és $p$ i-ekvivalens állapotok ($q \sim^i p$), ha minden max $i$ hosszú szóra egyformán működnek
+		\2 $\forall u \in T^*, \ell(u) \le i: (qu \atos r \wedge pu \atos r') \implies (r \in F \Leftrightarrow r' \in F)$
+		\2 Lemma: $q \sim^{i+1} p \Leftrightarrow (\forall a \in T: (qa \to r \wedge pa \to t) \implies r \sim^i t)$
+		\2 $q \sim^0 p \Leftrightarrow (q,p \in F \lor q,p \in Q \setminus F)$
+	\1 Particionálás folyamata
+		\2 Folyamatosan egyre hosszabb szavak alapján particionálunk
+		\2 $\epsilon$, először két rész: $Q = B_1 \cup B_2$, $B_1 = F$, $B_2 = Q \setminus F$
+		\2 Finomítás:
+			\3 Legyen $q \sim^i p$ és a partíciók száma $k \ge 2$ ($Q = B_1 \cup ... \cup B_k$)
+			\3 $p,q \in B_i$ pontosan akkor maradnak egy partícióban, ha:\\
+			$\forall a \in T: (qa \to r \wedge pa \to t) \implies (r,t \in B_i)$\\
+			azaz ha $r,t$ azonos partícióba tartoznak, ilyenkor $q \sim^{i+1} p$
+			\3 Ellenkező esetben a $B_i$ partíciót szét kell bontani
+			\3 Ezt az eljárást addig ismételjük, amíg változás van
+\end{outline}
+
+\pagebreak
+
+\section{Előadás 6: $\mathcal{G}_2$ típusú grammatikák, veremautomata}
+
+\subsection{Programozási nyelvek szintaxisa}
+
+\begin{outline}
+	\1 Programozási nyelvek szintaxisa: környezetfüggetlen ($\mathcal{G}_2$)
+\end{outline}
+
+\subsubsection{Szóprobléma}
+
+\begin{outline}
+	\1 Tétel: $\forall G \in \mathcal{G}_2$ eldönthető, hogy $u \in T^*$ esetén $u \in L(G)$ igaz-e
+		\2 Nem bizonyítjuk
+\end{outline}
+
+\subsubsection{Backus-Naur forma (BNF)}
+
+\begin{outline}
+	\1 Szabály bal-jobb oldal elválasztó: $::=$
+	\1 Nemterminális: $<$ és $>$ jelek között (minden más terminális)
+	\1 \begin{verbatim}
+	<kifejezés> ::= <tag> | <tag> + <kifejezés>
+	<tag> :: = <faktor> | <faktor> * <tag>
+	<faktor> ::= i | ( <kifejezés> )
+	\end{verbatim}
+		\2 Pár helyes kifejezés: $i+i*i,\; (i+i)*i,\; i*i*i*i,\; ((i)),\; i$
+\end{outline}
+
+\subsubsection{Szintaxisfa}
+
+\begin{outline}
+	\1 Legyen $G = (N,T,P,S) \in \mathcal{G}_2$
+	\1 A $t$ nemüres fa szintaxisfa, ha...:
+		\2 Belső pontjai $N$ elemeivel vannak címkézve
+		\2 Levelei $T \cup \{\epsilon\}$ elemeivel vannak címkézve
+			\3 $\epsilon$-nal címkézett pontoknak nincs testvére
+		\2 Ha egy belső pont címkéje $A$ és közvetlen gyerekei\\
+		$X_1, X_2, ..., X_n$, akkor $A \to X_1X_2...X_n \in P$
+	\1 Szóhoz megadható szintaxisfa $\Leftrightarrow$ létezik levezetés
+	\1 Egyértelmű grammatika: $\forall u \in L(G)$ szóhoz egyetlen szintaxisfa tartozik
+		\2 Nem egyértelmű példa: $S \to a \;|\; S + S$ az $u=a+a+a$ esetben
+\end{outline}
+
+\pagebreak
+
+\subsection{Chomsky normál forma ($\mathcal{G}_2$)}
+
+\begin{outline}
+	\1 Emlékeztető: $A \to a$ vagy $A \to BC$ a szabályok ($a \in T$; $A,B,C \in N$)
+		\2 Vagy $S \to \epsilon$, de ekkor $S$ csak bal oldalon van
+	\1 Bináris szintaxisfák jönnek ki ilyen grammatikákból
+	\1 Aktív nemterminálisok halmaza
+		\2 Jelentése: valahány lépésben csupa terminális csinálható belőle
+		\2 $A = \{ X \in N \;|\; X \gtos u \wedge u \in T^* \}$
+		\2 Inaktív nemterminálisok halamza: $N \setminus A$
+		\2 $A = \emptyset \;\; \implies \;\; L(G) = \emptyset$
+	\1 Elérhető nemterminálisok halamza:
+		\2 Jelentése: kezdőállapotból el lehet bele jutni
+		\2 $R = \{ X \in N \;|\; S \gtos uXw \wedge u,w \in (T \cup N)^* \}$
+			\3 Nem lehet üres: $S$ mindig benne van
+		\2 Nem elérhető nemterminálisok halmaza: $N \setminus R$
+	\1 Hasznos nemterminálisok: aktív és elérhető ($A \cap R$)
+	\1 Redukált grammatika: minden nemterminális hasznos ($N = A \cap R$)
+\end{outline}
+
+\pagebreak
+
+\subsection{Lemmák $\mathcal{L}_3$, $\mathcal{L}_2$ kapcsán}
+
+\subsubsection{Kis Bar-Hillel lemma, szükséges feltétel $L \in \mathcal{L}_3$-ra}
+
+\begin{outline}
+	\1 Minden $L \in \mathcal{L}_3$ nyelvhez van $n \ge 1$ nyelvfüggő konstans
+	\1 Hogy $\forall u \in L$ ahol $\ell(u) \ge n$ van olyan $u = xyz$ felbontás
+		\2 $\ell(xy) \le n$
+		\2 $y \ne \epsilon$
+		\2 $\forall i \ge 0: xy^i z \in L$
+\end{outline}
+
+\subsubsection{Kis Bar-Hillel lemma bizonyítása}
+
+\begin{outline}
+	\1 $L \in \mathcal{L}_3 \implies$ adható minimális VDA
+	\1 Tegyük fel, hogy az automatának $n$ állapota van
+	\1 Szó legalább $n$ hosszó $\implies$ legalább $n$ hosszú prefixének olvasásakor legalább egy állapot kétszer volt érintve, azaz tettünk egy kört
+		\2 Ezt a kört kihagyhatjuk (i=0) vagy akárhányszor ismételhetjük
+\end{outline}
+
+\subsubsection{Példa és lemma alapján $\mathcal{L}_3 \subset \mathcal{L}_2$ belátása}
+
+\begin{outline}
+	\1 $L=\{ a^k b^k \;|\; k \ge 0 \} \notin \mathcal{L}_3$ bizonyítása
+	\1 Tegyük fel indirekt, hogy $\exists n \ge 1$ a lemma szerint
+	\1 Legyen $u=a^k b^k$ ahol $k > n$
+	\1 Ekkor léteznie kéne egy $u = xyz$ felbontásnak ahol $\ell(xy) \le n$ és $y \ne \epsilon$
+	\1 De $k > n$ miatt $y$ csak 'a' betűket tartalmazhat
+	\1 Lemma szerint $a^{k+j}b^k$ szónak is $\in L$, de ez nem igaz
+\end{outline}
+
+\pagebreak
+
+\subsubsection{Bar-Hillel lemma (pumpáló lemma)}
+
+\begin{outline}
+	\1 Minden környezetfüggetlen nyelvhez megadható $p,q$
+	\1 $\forall u \in L: \ell(u) > p \implies u = vxwyz$
+		\2 $v,x,w,y,z \in T^*$
+		\2 $\ell(xwy) \le q$
+		\2 $xy \ne \epsilon$
+		\2 $\forall i \ge 0: v x^i w y^i z \in L$
+	\1 Párhuzamos pumpálás szemléletesen
+	\1 Nem bizonyítjuk (de Chomsky-normálforma, bináris fa alapján kell)
+\end{outline}
+
+\subsubsection{Bar-Hillel lemma $\implies$ van környezetfüggő nyelv}
+
+\begin{outline}
+	\1 Példa: $L = \{ a^n b^n c^n \;|\; n > 0 \} \notin \mathcal{L}_2$
+	\1 Bizonyítás: indirekt, tegyük fel, hogy létezik $p$ és $q$
+	\1 Legyen $k >p$ és $k > q$, ekkor $u = a^k b^k c^k$ és $\ell(u) > p$
+	\1 Tétel szerint $x$ és $y$ párhuzamosan iterálható, de $xy$-ban nem lehet mindhárom betűből
+\end{outline}
+
+\pagebreak
+
+\subsection{Veremautomata}
+
+\begin{outline}
+	\1 $A = (Z,Q,T,\delta,z_0,q_0,F)$
+		\2 $Z$: verem szimbólumok ábécéje (nem üres)
+		\2 $Q$: állapotok halmaza (véges és nem üres)
+		\2 $T$: bemeneti szimbólumok ábécéje
+		\2 $\delta: Z \times Q \times (T \cup \{\epsilon\}) \to \mathcal{P}(Z^* \times Q)$
+			\3 Lehet determinisztikus vagy nem determinisztikus
+			\3 Verem tetejét mindig kiveszi (de vissza is rakhatja, akár többet)
+			\3 Bár $Z^*$ lehet végtelen, mi csak véges sok szabályt engedünk
+		\2 $z_0 \in Z$: kezdő veremszimbólum (verem nem üresen kezd)
+		\2 $q_0 \in Q$: kezdőállapot
+		\2 $F \subseteq Q$: elfogadó állapotok halmaza
+	\1 VDA-tól eltérés: $Z$, $z_0$ és $\delta$
+	\1 Elfogadó állapotba kerüléskor nem feltétlenül üres a verem
+	\1 Verem üres $\implies$ (szó helyes $\Leftrightarrow$ elfogadóállapotban vagyunk)
+		\2 Bemenetből olvasható $\epsilon$, de veremből nem!
+	\1 Nem feltétlenül terminál ($\epsilon$-t olvashat bemenetről)
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.7\linewidth]{veremautomata-példa}
+\end{figure}
+
+\end{document}
diff --git "a/fonya-fordprog/form\303\241lis-nyelvek/grammatika-t\303\255pusok.png" "b/fonya-fordprog/form\303\241lis-nyelvek/grammatika-t\303\255pusok.png"
new file mode 100644
index 0000000..34dad46
Binary files /dev/null and "b/fonya-fordprog/form\303\241lis-nyelvek/grammatika-t\303\255pusok.png" differ
diff --git "a/fonya-fordprog/form\303\241lis-nyelvek/veremautomata-p\303\251lda.png" "b/fonya-fordprog/form\303\241lis-nyelvek/veremautomata-p\303\251lda.png"
new file mode 100644
index 0000000..11615b1
Binary files /dev/null and "b/fonya-fordprog/form\303\241lis-nyelvek/veremautomata-p\303\251lda.png" differ
diff --git "a/numm\303\263d1/README.md" "b/numm\303\263d1/README.md"
new file mode 100644
index 0000000..8414ac2
--- /dev/null
+++ "b/numm\303\263d1/README.md"
@@ -0,0 +1,7 @@
+**Képzés:** ELTE IK Proginf BSc, Szoftvertervező (B) szakirány (kezdés éve: 2020)  
+**Tárgy neve:** Numerikus módszerek I  
+**Tárgy kódja:** IP-18bNM1E/G
+
+Csak a gyakorlathoz kapcsolódó részekről szól a jegyzet. A vizsgára nem, viszont a gyakorlati ZH-kra a felkészülést segíti.
+
+[Jegyzet link](nummód2-gyak.pdf)
diff --git "a/numm\303\263d1/ge-sor-nulla.png" "b/numm\303\263d1/ge-sor-nulla.png"
new file mode 100644
index 0000000..4b9f4b9
Binary files /dev/null and "b/numm\303\263d1/ge-sor-nulla.png" differ
diff --git "a/numm\303\263d1/lu-sorrend.png" "b/numm\303\263d1/lu-sorrend.png"
new file mode 100644
index 0000000..26754e0
Binary files /dev/null and "b/numm\303\263d1/lu-sorrend.png" differ
diff --git "a/numm\303\263d1/numm\303\263d1-gyak.pdf" "b/numm\303\263d1/numm\303\263d1-gyak.pdf"
new file mode 100644
index 0000000..d83122a
Binary files /dev/null and "b/numm\303\263d1/numm\303\263d1-gyak.pdf" differ
diff --git "a/numm\303\263d1/numm\303\263d1-gyak.tex" "b/numm\303\263d1/numm\303\263d1-gyak.tex"
new file mode 100644
index 0000000..afc76ac
--- /dev/null
+++ "b/numm\303\263d1/numm\303\263d1-gyak.tex"
@@ -0,0 +1,831 @@
+% !TeX spellcheck = hu_HU
+\documentclass[12pt,a4paper]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{cmap}
+\usepackage[T1]{fontenc}
+\usepackage[magyar]{babel}
+\usepackage{amsmath}
+\usepackage{amsfonts}
+\usepackage{amssymb}
+\usepackage{graphicx}
+
+\usepackage{outlines}
+\usepackage{hyperref}
+
+\hyphenpenalty=10000
+
+\begin{document}
+
+\begin{center}
+	\huge
+	Numerikus módszerek I\\
+	\vspace{1mm}
+	\LARGE
+	Gyakorlat jegyzet\\
+	\vspace{5mm}
+	\large
+	Készült Bozsik József előadásai és gyakorlatai alapján\\
+	\vspace{5mm}
+	Sárközi Gergő, 2021-22-2. félév\\
+	Nincsen lektorálva!
+\end{center}
+
+\tableofcontents
+
+\pagebreak
+
+\section{Gépi számábrázolás, hibaszámítás}
+
+\subsection{Gépi számok, lebegőpontos számábrázolás egy modellje}
+
+\begin{outline}
+	\1 Normalizált lebegőpontos szám: $a = \pm m * 2^k = \pm [m_1 ... m_t | k]$
+		\2 $m$: mantissza, hossza $t$, $m=\sum_{i=1}^{t} m_i*2^{-i}$ \; ($m_1=1$; $m_i \in \{0,1\}$)
+		\2 $k$: karakterisztika, $k^- \le k \le k^+$
+	\1 Gép számok halmaza: $M=M(t,k^-,k^+)$ \; ($k^-,k^+ \in \mathbb{Z}$ és $t \in \mathbb{N}$)
+		\2 $M(t,k^-,k^+) = \{\pm 2^k * \sum_{i=1}^{t} m_i * 2^{-i} \} \cup \{0\}$
+		\2 Gyakran hozzávesszük: $+\infty, -\infty, NaN$
+	\1 Gép számok halmazának tulajdonságai:
+		\2 $\frac{1}{2} \le m < 1$ \; és \; $M$ szimmetrikus 0-ra
+		\2 $\epsilon_0$: legkisebb pozitív elem: $\epsilon_0 = [100...0|k^-] = \frac{1}{2} * 2^{k^-} = 2^{k^- - 1}$
+		\2 $M_\infty$: legnagyobb elem: $M_\infty = [111...1|k^+] = (1-2^{-t}) * 2^{k^+}$
+		\2 $M$-ben az $1$ után következő gépi szám és az $1$ különbsége:\\
+		$\epsilon_1 = [100...01|1] - [100....00|1] = 2^{-t} * 2^1 = 2^{1-t}$
+		\2 $|M|$: $M$ számossága: $|M|=2*2^{t-1}*(k^+ - k^- + 1) + 1$
+\end{outline}
+
+\subsection{Valós számok ábrázolása gépi számmal}
+
+\begin{outline}
+	\1 Ábrázolható számok tartománya: $\mathbb{R}_M = \{x \in \mathbb{R}: |x| \le M_\infty\}$
+	\1 Input függvény, $fl : \mathbb{R}_M \to M$: $x$-hez $\widetilde{x}$-et rendel
+		\2 $\widetilde{x}$ az $x$-hez legközelebbi gépi szám, kerekítés szabályai szerint
+		\2 $fl(x) = \begin{cases}
+		0 &\text{ ha } |x| < \epsilon_0\\
+		\widetilde{x} &\text{ ha } \epsilon_0 \le |x| \le M_\infty\\
+		+\infty &\text{ ha } |x| > M_\infty
+		\end{cases}$
+\end{outline}
+
+\subsubsection{Hibakorlátok}
+
+\begin{outline}
+	\1 Input hiba: $\forall x \in \mathbb{R}_M: |x-fl(x)| \le \begin{cases}
+		\epsilon_0 \;\;\;\;\;\;\;\;\;\;\;\;\;\;\;\;\; \text{ha} \;\; |x| < \epsilon_0 \\
+		0.5*|x|*\epsilon_1 \;\; \text{ha} \;\; \epsilon \le |x| \le M_\infty
+	\end{cases}$
+	\1 Abszolút hibakorlát: $\Delta_x = 0.5 * 2^k * 2^{-t}$
+	\1 Relatív hibakorlát: $\delta_x = 2^{-t}$
+\end{outline}
+
+\pagebreak
+
+\subsubsection{Input függvény a gyakorlatban}
+
+\begin{outline}
+	\1 Feladat: $M(5,-4,4)$-ben $fl(10,85) = \; ?$
+	\1 Első lépés: szám átalakítása 2-es számrendszerbe
+		\2 Táblázatban lehet egyből törtet is átalakítani, pl. $1/6$
+		\2 Kezdő nullákat elhagyjuk, a karakterisztikát annyival eltoljuk
+
+\begin{table}[h]
+	\centering
+	\begin{tabular}{|c|c|c|c|c|}
+		\hline
+		10 & 5 & 2 & 1 & 0 \\
+		\hline
+		$(:2)$ & 0 & 1 & 0 & 1 \\
+		\hline
+		$1010_{(2)}$ & $\leftarrow$ & $\leftarrow$ & $\leftarrow$ & $\leftarrow$ \\
+		\hline
+	\end{tabular}
+	\caption{Egészrész binárisba alakítása}
+\end{table}
+
+\begin{table}[h]
+	\centering
+	\begin{tabular}{|c|c|c|c|c|c|c|c|}
+		\hline
+		85 & 70 & 40 & 80 & 60 & 20 & 40 & 80 \\
+		\hline
+		$(*2)$ & 1 & 1 & 0 & 1 & 1 & 0 & 0 \\
+		\hline
+		$\approx 0.11011_{(2)}$ & $\rightarrow$ & $\rightarrow$ & $\rightarrow$ & $\rightarrow$ & $\rightarrow$ & $\rightarrow$ & $\rightarrow$ \\
+		\hline
+	\end{tabular}
+		\caption{Törtrész binárisba alakítása}
+\end{table}
+
+		\2 Eredmény: $10,85 \approx 1010.11011_{(2)} = 1010.1|1011_{(2)}$
+	\1 Második lépés: kerekítés
+		\2 Eredmény: $fl(10,85) = [10110|4] = \frac{22}{32} * 2^4 = 11$
+	\1 Harmadik lépés: hibaszámolás: $|10,85 - fl(10,85)| = 0,15$
+\end{outline}
+
+\subsection{Gépi számok összeadása}
+
+\begin{outline}
+	\1 Azonos karakterisztikájú számok összeadása:
+	mantisszák összeadása, szükség esetén normalizálás (kerekítéssel)
+	\1 Eltérő karakterisztikájú számok összeadása:
+	kisebbik karakterisztikát a nagyobbikhoz igazítjuk (kerekítünk, ha kell), majd normál összeadás
+	\1 Van rá példa: $b \ne 0 \wedge a \oplus b = a$
+		\2 pl. $b$ karakterisztikája $\le$ $a$ karakterisztikája + mantissza + 1\\
+		$[10011|4] \oplus [10010|-2] \implies 0.10010_{(2)}*2^{-2} = 0.00000010010_{(2)}*2^4$
+	\1 Van rá példa: asszociativitás nem teljesül
+		\2 pl. (nagy+kicsi)+kicsi \; vs \; nagy+(kicsi+kicsi)
+	\1 ZH-ban részletesen le kell vezetni pl. a karakterisztika váltást
+\end{outline}
+
+\pagebreak
+
+\subsection{Hibaszámítás elemei}
+
+\subsubsection{Hibák jellemzése}
+
+\begin{outline}
+	\1 Legyen $A$ egy pontos érték, $a$ pedig egy közelítő érték
+	\1 $\Delta a = A - a$: közelítő érték pontos hibája
+	\1 $|\Delta a| = |A - a|$: közelítő érték abszolút hibája
+	\1 $\Delta_a \ge |\Delta a|$: közelítő érték abszolút hibakorlátja
+	\1 $\delta a = \frac{\Delta a}{A} \approx \frac{\Delta a}{a}$: közelítő érték relatív hibája
+	\1 $\delta_a \ge |\delta a|$: közelítő érték relatív hibakorlátja
+	\1 Kerekítés abszolút hibakorlát: 2 tizedesjegyes kerekítés esetén $0.005$
+\end{outline}
+
+\subsubsection{Alapműveletek hibakorlátai}
+
+\begin{outline}
+	\1 Tétel: alapműveletek hibakorlátai
+		\2 $\Delta_{a \pm b} = \Delta_a + \Delta_b$ \;\;\;\;\;\;\;\;\;\;\;\;\;\;\;\;\;\;\;\;
+		$\delta_{a \pm b} = (|a|\delta_a+|b|\delta_b) \;/\; |a \pm b|$
+		\2 $\Delta_{a * b} = |b|\Delta_a + |a|\Delta_b$ \;\;\;\;\;\;\;\;\;\;\;\;\;\;
+		$\delta_{a * b} = \delta_a + \delta_b$
+		\2 $\Delta_{a / b} = (|b|\Delta_a + |a|\Delta_b) \;/\; b^2$ \;\;\;\;\;
+		$\delta_{a / b} = \delta_a + \delta_b$
+	\1 Két esetben van nagyságrendileg nagyobb hiba, ezeket érdemes elkerülni:
+		\2 $\delta_{a \pm b}$: közeli számok kivonása egymásból
+		\2 $\Delta_{a/b}$: kicsi számmal osztás
+\end{outline}
+
+\subsubsection{Függvényérték hibája, kondíciószáma}
+
+\begin{outline}
+	\1 Függvényérték relatív hibája: Ha $\Delta_a$ kicsi, akkor $\delta_{f(a)} = \frac{|a||f'(a)|}{|f(a)|}*\delta_a$
+	\1 $f$ függvény $a$-beli kondíciószáma: $c(f,a)=\frac{|a||f'(a)|}{|f(a)|}$
+\end{outline}
+
+\pagebreak
+
+\section{Mátrixokról általánosságban}
+
+\begin{outline}
+	\1 $a_{ij}$ jelentése: i. sor, j. oszlop az $A$ mátrixban
+	\1 $\mathcal{U}$: felső háromszögmátrixok
+	\1 $\mathcal{L}_1$: alsó háromszögmátrixok; főátlójukban csupa $1$-es van
+	\1 $A^T$ jelentése: főátlóra tükrözés
+	\1 Szimmetrikus mátrix: $A = A^T$
+	\1 Sorokra/oszlopokra szigorúan diagonálisan domináns mátrix: főátlóban lévő elemek abszolútértéke szigorúan nagyobb, mint az adott sorban/oszlopban lévő elemek abszolútértékének összege (átlót nem beleszámítva)
+\end{outline}
+
+\subsection{Pozitív definit mátrix definíció}
+
+\begin{outline}
+	\1 Legyen szimmetrikus (TODO ebben a tárgyban ez feltétel vagy sem?)
+	\1 Ezek közül legyen egy igaz (ha egy igaz, az akkor az összes is):
+		\2 $<Ax,x> = x^TAx>0$ bármely $0 \ne x \in \mathbb{R}^n$ esetén
+		\2 minden főminorjának determinánsa pozitív
+		\2 minden sajátértéke pozitív
+	\1 Példa pozitív definit mátrixra: diagonális és minden eleme pozitív
+\end{outline}
+
+\subsection{Ortogonális mátrix, ortonormált rendszer}
+
+\begin{outline}
+	\1 Ortogonális mátrix: $Q^T = Q^{-1}$
+		\2 Oszlopaik, mint vektorok, ortonormált rendszert alkotnak
+		\2 Ortogonális mátrixok szorzata is ortogonális
+	\1 Ortonormált rendszer: $<q_i,q_j> = \begin{cases}
+	0 & $\text{ ha }$ i \ne j\\
+	1 & $\text{ ha }$ i = j
+	\end{cases}$
+		\2 Ortogonális rendszer: $i=j$ esetében lehet bármi, nem csak $1$
+\end{outline}
+
+\subsection{Sajátérték számolás}
+
+\begin{outline}
+	\1 $|A - \lambda I| = 0$, azaz főátlón mindenhol kivonunk $\lambda$-t, kiszámoljuk a paraméteres determinánst és megoldunk egy egyenlőséget ($det = 0$)
+\end{outline}
+
+\pagebreak
+
+\subsection{Determináns számolás}
+
+\begin{outline}
+	\1 $1 \times 1$ mátrix: a szám maga
+	\1 $\begin{bmatrix} a & b \\ c & d \end{bmatrix}$ mátrix: $ad - bc$
+	\1 $\begin{bmatrix} a & b & c \\ d & e & f \\ g & h & i \end{bmatrix}$ mátrix:
+	$a * \begin{vmatrix} e & f \\ h & i \end{vmatrix}
+	- b * \begin{vmatrix} d & f \\ g & i \end{vmatrix}
+	+ c * \begin{vmatrix} d & e \\ g & h \end{vmatrix}$
+		\2 Lehet sor helyett oszlop szerint is kibontani
+	\1 Determináns tartó műveletek:
+		\2 egy sorhoz hozzáadni egy másik sor konstans-szorosát
+	\1 Determináns meg kell szorozni $(-1)^n$-szer: oszlop, sorcserék száma
+	\1 Kapcsolat önmagával:
+		\2 $\det(A^T) = \det(A)$
+		\2 $\det(AB) = \det(A) \det(B)$
+		\2 $\det(A^{-1}) = 1 / \det(A)$
+		\2 $n \times n$-es mátrix: $\det(cA) = c^n * \det(A)$
+	\1 Háromszög mátrix: determináns a főátlón lévő elemek szorzata
+	\1 Főminorok: egy mátrix bal felső almátrixjainak a determinánsai
+		\2 $D_k$ a $k \times k$ bal felső részmátrix determinánsa
+\end{outline}
+
+\subsection{Invertálás}
+
+\begin{outline}
+	\1 Diagonális mátrix: (főátló) elemeinek reciproka
+	\1 $A^{-1} = \begin{bmatrix} a & b \\ c & d \end{bmatrix}^{-1} =
+	\frac{1}{det(A)} \begin{bmatrix} d & -b \\ -c & a \end{bmatrix}$
+	\1 $\begin{bmatrix} a & b & c \\ 0 & d & e \\ 0 & 0 & f \end{bmatrix}^{-1}
+	= \begin{bmatrix} 1/a & -b/(ad) & (be-cd)/(afd) \\ 0 & 1/d & -e/(fd) \\ 0 & 0 & 1/f \end{bmatrix}$
+		\2 Alsó háromszögmátrix: ugyan így
+\end{outline}
+
+\pagebreak
+
+\section{Gauss-elimináció (GE)}
+
+\begin{outline}
+	\1 Alak: [A|b]
+	\1 Első rész: főátló alatt nullázás, balról jobbra
+		\2 Ezután már egyből lehet determinánst számolni
+	\1 Második rész: főátló fölött nullázás, jobbról balra, sor osztása magával
+		\2 Kihagyható: egyenletrendszerrel enélkül is megoldható az $Ax=b$
+	\1 Nullázás: a pillanatnyi sor konstans-szorosát hozzáadjuk egy másikhoz
+	\1 Inverz számolás: $b$ helyett az identitásmátrix legyen a jobb oldalon.\\
+	Ekkor amikor bal oldalon identitásmátrix van: jobb oldalon az inverz.
+	\1 Sorcsere: nem változik a megoldás
+	\1 Oszlopcsere: a megoldás komponensei cserének megfelelően változnak
+	\1 Főátlón 0 van, alatta/felette nem: oszlop/sorcsere kell
+	\1 Nincs megoldás: ha bal oldalon 0-k vannak a sorban, jobb oldalon nem
+	\1 Függő paraméter: ha egy sorban csak 0-k vannak mindkét oldalt
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.7\linewidth]{ge-sor-nulla}
+\end{figure}
+
+\subsection{Főelemkiválasztás}
+
+\begin{outline}
+	\1 Részleges főelemkiválasztás: adott oszlopban maximális abszolút értékű elem (sor) kiválasztása (ami a főátlón vagy az alatt van), áthelyezése a főátlóra, és a többi sor azzal való eliminálása
+	\1 Teljes főelemkiválasztás: részleges főelemkiválasztás, csak bármelyik oszlopból választunk (de mindig csak a jobb alsó részmátrixból)	
+\end{outline}
+
+\pagebreak
+
+\section{$LU$ felbontás ($A = LU$, ahol $L \in \mathcal{L}_1$ és $U \in \mathcal{U}$)}
+
+\begin{outline}
+	\1 Felhasználás: $Ax=b$ helyett $Ly=b$ (alsó $\Delta$) és $Ux=y$ (felső $\Delta$)
+\end{outline}
+
+\subsection{Gauss-eliminációval (GE-vel)}
+
+\begin{outline}
+	\1 $L_{n-1} * ... * L_2 * L_1 * A = U \implies
+	A = L_1^{-1} * L_2^{-1} * ... * L_{n-1}^{-1} * U = LU$
+	\1 Minden GE lépés egy $L_i \in \mathcal{L}_1$, elemei: hányszorost adtunk a sorhoz
+	\1 $L_i$ invertálásakor az elemek előjelet cserélnek, ekkor elemek: $\frac{\text{adott sorbeli érték}}{\text{elemináló sor értéke}}$
+	\1 Tömör írásmód: nem hozunk létre $L_i$ mátrixokat, hanem a GE-ben használt mátrix alsó részét vastag vonallal leválasztjuk és oda írjuk be a végső $L$ értékeit, folyamatosan, ahogy kiszámoljuk őket
+\end{outline}
+
+\subsection{Létezés (ami $\ne$ LER megoldhatóság)}
+
+\begin{outline}
+	\1 GE végrehajtható sor- és oszlopcsere nélkül $\implies$ létezik $LU$ felbontás
+	\1 $D_k$ főminorok $\ne 0 \implies$ létezik $LU$ felbontás (és $u_{kk} \ne 0$)
+	\1 $\det(A) \ne 0 \implies$ az $LU$ felbontás egyértelmű
+\end{outline}
+
+\subsection{$LU$ mátrixok közvetlen kiszámolása (GE nélkül)}
+
+\begin{outline}
+	\1 Írjuk fel az $L,U$ mátrixokat változókkal (minden elem $0$ vagy egy változó)
+		\2 Segítség: $U$ és $A$ első sora megegyezik
+		\2 Segítség: $A$ első oszlopa leosztva $a_{11}$-gyel egyezik $L$ első oszlopával
+	\1 Egy jó sorrendben (lásd kép) számoljuk ki a változókat: mátrixszorzás eredményét tudjuk, vissza kell fejtenünk a változókat
+		\2 Ellentmondás $\implies$ az $LU$ felbontás nem létezik
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.8\linewidth]{lu-sorrend}
+\end{figure}
+
+\pagebreak
+
+\section{$LDU$ felbontás ($L \in \mathcal{L}_1$, $U \in \mathcal{U}_1$, $D$ diagonális)}
+
+\begin{outline}
+	\1 Előállítás $LU$ felbontásból: $A = L \widetilde{U} = LD * (D^{-1} \widetilde{U}) = LDU$
+		\2 $\widetilde{U}$ főátlóját átmásoljuk $D$-be, helyére $1$-esek kerülnek
+		\2 $\widetilde{U}$ minden többi elemét leosztjuk $\widetilde{U}$ azonos sorának főátlóbeli elemével
+		\2 Így megkaptuk az $U$ mátrixot, $L$ mátrixot pedig békén hagyjuk
+\end{outline}
+
+\subsection{Szimmetrikus $A$ mátrix, $LDL^T$ felbontás}
+
+\begin{outline}
+	\1 Szimmetrikus az $A$ mátrix $\implies LDU=LDL^T$
+	\1 GE-vel elég csak a főátlót ($D$) és az alsó részt ($L$) tárolni
+\end{outline}
+
+\section{Cholesky ($LL^T$) felbontás ($L \in \mathcal{L}$)}
+
+\begin{outline}
+	\1 Felhasználás: $Ax=b$ helyett $Ly=b$ (alsó $\Delta$) és $L^Tx=y$ (felső $\Delta$)
+	\1 $A$ szimmetrikus és $A$ pozitív definit $\implies$ létezik és egyértelmű
+	\1 Előállítás $LDU$ felbontásból: $A = \widetilde{L}D\widetilde{L}^T =
+	\widetilde{L} \sqrt{D} \sqrt{D} \widetilde{L}^T = LL^T$\\
+	$D$ minden eleméből gyököt vonunk, ezzel megszorozzuk $\widetilde{L}$-t:\\
+	$L = \widetilde{L} * \sqrt{D}$ és $L^T = \sqrt{D} * \widetilde{L}^T$
+	($L$: oszlop; $L^T$: sor szorzás $D$ elemével)
+	\1 Előállítás GE-vel: minden lépésben osztjuk az oszlopot $\sqrt{a_{kk}}$-val
+\end{outline}
+
+\pagebreak
+
+\section{$QR$ felbontás, Gram-Schmidt féle ortogonalizáció}
+
+\begin{outline}
+	\1 $Q$ ortogonális mátrix, $R \in \mathcal{U}$
+	\1 Felhasználás: $Qy = b \implies y = Q^Tb$ és $Rx = y$ (felső $\Delta$)
+		\2 Egybe írva: $Rx = Q^Tb$
+	\1 $\det(A) \ne 0 \implies$ létezik $QR$ felbontás
+		\2 $\forall r_{ii} > 0 \implies$ egyértelmű a $QR$ felbontás
+\end{outline}
+
+\subsection{Gram-Schmidt féle ortogonalizáció, folyamatos normálás}
+
+\begin{outline}
+	\1 $a_i$ jelentése: $A$ mátrix $i.$ oszlopa
+	\1 $r_{11} = ||a_1||$ és $q_1 = \frac{1}{r_{11}} a_1$
+	\1 $k$: hányadik lépés van most ($k=2,..,n$); valamint: $j = 1,...,k-1$
+	\1 $r_{jk} = <a_k,q_j>$
+	és $s_k = a_k - \sum_{j=1}^{k-1} r_{jk} * q_j$
+	és $r_{kk} = ||s_k||$
+	és $q_k = \frac{1}{r_{kk}}s_k$
+\end{outline}
+
+\subsection{Gram-Schmidt féle ortogonalizáció, normálás utólag}
+
+\begin{outline}
+	\1 $\widetilde{r}_{11} = \widetilde{r}_{kk} = 1$ és $\widetilde{q}_1 = a_1$
+	\1 $\widetilde{r}_{jk} = <a_k,\widetilde{q}_j> / <\widetilde{q}_j,\widetilde{q}_j>$
+	\; és \; $\widetilde{q}_k = a_k - \sum_{j=1}^{k-1} \widetilde{r}_{jk} * \widetilde{q}_j$
+	\1 Ilyenkor már $A=\widetilde{Q}\widetilde{R}$, de $Q$ nem ortonormált
+	\1 $Q$ elkészítése: $\widetilde{Q}$ oszlopait ($\widetilde{q}_i$)
+	le kell osztani $||\widetilde{q}_i||$-vel
+	\1 $R$ elkészítése: $\widetilde{R}$ sorait meg kell szorozni $||\widetilde{q}_i||$-vel\\
+	(A legfelső sort a leg bal oldalibb oszloppal kell szorozni.)
+\end{outline}
+
+\pagebreak
+
+\section{Householder transzformáció}
+
+\begin{outline}
+	\1 Householder mátrix: $H(v) = I - 2vv^T$ ahol $||v||=1$
+		\2 $H(v)$ tükröző mátrix, $v$ normálvektorú, $n-1$ dim. altérre tükröz
+		\2 Szimmetrikus ($H^T=H$), ortogonális ($H^{-1} = H$ és $||x||=||H(v)x||$)
+		\2 $H(v) * v = -v$ és $\forall y \perp v: H(v) * y = y$
+		\2 Nem kell előállítani, a Householder transzformáció anélkül is alkalmazható:\\
+		$H(v)x = (I - 2vv^T)x = x - 2v(v^Tx)$ ahol $v^Tx \in \mathbb{R}$ és $x \in R^n$\\
+		$y^TH(v) = y^T(I - 2vv^T) = y^T - 2(y^Tv)v^T$ ahol $y^Tv \in \mathbb{R}$ és $y \in R^n$
+	\1 Tükrözés: $v = \pm \frac{a-b}{||a-b||}$, $a \ne b$, $||a||=||b|| \ne 0$ esetén: $H(v)a=b$
+\end{outline}
+
+\subsection{Egy $a$ vektor $b = k * e_1$ alakúra hozása}
+
+\begin{outline}
+	\1 $k = -1 * signum(a_1) * ||a||$ \;\; és \;\;
+	$v = \frac{a - k e_1}{||a - k e_1||}$
+	\1 Ekkor: $H(v) * a = a - 2v(v^Ta) = a - 2(v^Ta)v = k e_1$ \;\; ($2(v^Ta) \in \mathbb{R}$)
+\end{outline}
+
+\subsection{LER megoldás Householder transzformációval}
+
+\begin{outline}
+	\1 Cél: felső háromszög alakra hozás
+	\1 Minden lépésben egy oszlopot $k*e_1$ alakúra hozunk
+	\1 A transzformációt a többi oszlopon és $b$-n is elvégezzük:\\
+	$c := c - 2(v^Tc)v$ ahol $c$ egy tetszőleges oszlop (vagy $b$)
+		\2 Ha $c$ az az oszlop, amivel létrehoztuk $v$-t: az eredmény $k*e_1$
+	\1 Következő lépésben eggyel kisebb mátrixon folytatjuk
+\end{outline}
+
+\subsection{$QR$ felbontás Householder transzformációkkal}
+
+\begin{outline}
+	\1 TODO nem sikerült felfognom/megértenem, de minta ZH-ban sem volt
+\end{outline}
+
+\pagebreak
+
+%%%%%%%%%%%%%%%%%%%%%
+% ZH 1-2 elválasztó %
+%%%%%%%%%%%%%%%%%%%%%
+
+\section{Mátrixnormák, vektornormák, kondíciószám}
+
+\subsection{Vektornormák}
+
+\subsubsection{Axiómák}
+
+\begin{outline}
+	\1 Az alábbi tulajdonságok mindegyikével bíró függvények a vektornormák
+	\1 $||x|| \ge 0$
+	\1 $||x|| = 0 \Leftrightarrow x = 0$
+	\1 $||\lambda * x|| = |\lambda| * ||x||$
+	\1 $||x+y|| \le ||x|| + ||y||$
+\end{outline}
+
+\subsubsection{Tudnivalók}
+
+\begin{outline}
+	\1 $||x||_\infty \le ||x||_2 \le ||x||_1$ \;de\;
+	$\exists c_1,c_2: c_1*||x||_b \le ||x||_a \le c_2*||x||_b$
+		\2 Azaz ekvivalensek a normák
+\end{outline}
+
+\subsubsection{Gyakori vektornormák}
+
+\begin{outline}
+	\1 Manhattan norma: $||x||_1 = \sum_{i=1}^n |x_i|$
+	\1 Euklideszi norma: $||x||_2 = \sqrt{<x,x>} = \sqrt{x^Tx} = \sqrt{\sum_{i=1}^{n} x_i^2}$
+	\1 Csebisev norma: $||x||_\infty = \max |x_i|$
+	\1 p-norma: $||x||_p = (\sum_{i=1}^{n} |x_i|^p)^{1/p}$ \;\; ($1 \le p < \infty$)
+\end{outline}
+
+\pagebreak
+
+\subsection{Mátrixnormák}
+
+\subsubsection{Axiómák}
+
+\begin{outline}
+	\1 Vektorok axiómái
+	\1 És egy extra: $||A*B|| \le ||A|| * ||B||$
+\end{outline}
+
+\subsubsection{Tudnivalók}
+
+\begin{outline}
+	\1 Indukált norma, természetes mátrixnorma: $||A|| = \sup \frac{||Ax||_v}{||x||_v}$ \; ($x \ne 0$)
+	\1 Illeszkedő norma: $||Ax||_v \le ||A|| * ||x||_v$
+	\1 Természetes mátrixnormák illeszkednek az őket indukáló vektornormákhoz
+\end{outline}
+
+\subsubsection{Gyakori mátrixnormák}
+
+\begin{outline}
+	\1 Frobenius-norma (nem indukált): $||A||_F = \sqrt{ \sum_{i=1}^{n} \sum_{j=1}^{n} |a_{ij}|^2 }$
+		\2 Illeszkedik a kettes vektornormához
+	\1 Oszlopnorma: $||A||_1 = \max_{j=1}^n \sum_{i=1}^{n} |a_{ij}|$ \;\; (oszlop szummák maximuma)
+	\1 Sornorma: $||A||_\infty = \max_{i=1}^n \sum_{j=1}^{n} |a_{ij}|$ \;\; (sor szummák maximuma)
+		\2 Szimmetrikus mátrix esetén megegyezik az oszlopnormával
+	\1 Spektrálnorma: $||A||_2 = \sqrt{\max_{i=1}^{n} \lambda_i (A^T A)} = \sqrt{\varrho(A^TA)}$
+		\2 $\lambda_i(A^T A)$ az $A^T A$ mátrix különböző sajátértékeket jelenti
+		\2 Spektrálsugár: $\varrho(A) = \max_{i=1}^{n} |\lambda_i(A)|$
+		\2 Szimmetrikus mátrix esetén: $||A||_2 = \varrho(A)$
+\end{outline}
+
+\pagebreak
+
+\subsection{Mátrixok kondíciószáma}
+
+\begin{outline}
+	\1 $\kappa(A) = cond(A) = ||A||*||A^{-1}||$
+	\1 Csak invertálható mátrixokra értelmes
+	\1 Értéke függ a választott normától
+	\1 Jellemzi LER feladat érzékenységét a (bemeneti, számábrázolási) hibára
+		\2 Minél nagyobb a kondíciószám, annál rosszabb
+\end{outline}
+
+\subsubsection{Tulajdonságok}
+
+\begin{outline}
+	\1 Indukált norma esetén: $cond(A) \ge 1$
+	\1 $c \ne 0 \implies cond(c*A) = cond(A)$
+\end{outline}
+
+\subsubsection{Speciális esetek}
+
+\begin{outline}
+	\1 Ha $Q$ ortogonális: $cond_2(Q) = 1$
+	\1 Ha $A$ szimmetrikus: $cond_2(A) = \frac{\max |\lambda_i(A)|}{\min |\lambda_i(A)|}$
+	\1 Ha $A$ invertálható: $cond(A) \ge \frac{\max |\lambda_i(A)|}{\min |\lambda_i(A)|}$
+\end{outline}
+
+\subsection{Reziduumvektor, maradékvektor}
+
+\begin{outline}
+	\1 Legyen $\widetilde{x}$ az $Ax=b$ LER egy közelítő megoldása
+	\1 Ekkor $r = b - A \widetilde{x}$ a reziduum- vagy maradékvektor
+	\1 Jellemzi megoldó módszer érzékenységét (bemeneti/számábrázolási) hibára
+		\2 Kondíciószám a feladat érzékenységét jellemzi, ez a megoldás módszerét
+	\1 Relatív maradék: $\eta = \frac{||r||}{||A||*||\widetilde{x}||}$
+		\2 Ha $A$ invertálható, akkor illeszkedő normában: $\eta \le \frac{||\Delta A||}{||A||}$
+		\2 Egyenlőség áll fenn kettes norma esetén
+\end{outline}
+
+\pagebreak
+
+\section{Iterációs módszerekről általánosságban}
+
+\begin{outline}
+	\1 $\varphi(x) = Bx+c$
+		\2 $B$: átmenet mátrix
+		\2 $x^{(0)}$ tetszőleges, $x^{(k+1)} = \varphi(x^{(k)})$
+	\1 Vektorsorozat akkor konvergens, ha\\
+	$\exists x^* \in \mathbb{R}^n: \forall \epsilon > 0: \exists N \in \mathbb{N}: \forall k > N: ||x^{(k)} - x^*|| < \epsilon$
+	\1 Iteráció és LER: $x^* = B x^* + c \;\;\Leftrightarrow\;\; (I - B) x^* = c \;\;\Leftrightarrow\;\; Ax=b$
+	\1 Fixponttétel: $x^*$ az $\varphi$ leképezés fixpontja, ha $x^* = \varphi(x^*)$
+\end{outline}
+
+\subsection{Kontrakció}
+
+\begin{outline}
+	\1 $\varphi$ kontrakció, ha $\exists q \in [0,1):
+	||\varphi(x) - \varphi(y)|| \le q * ||x-y||$ \; ($\forall x,y \in \mathbb{R}^n$)
+	\1 $q$ neve: kontrakciós együttható (minél kisebb, annál gyorsabb a kontrakció)
+	\1 Kontrakció esetén létezik egyértelmű fixpont	
+	\1 Nézzük a $\varphi(x) = Bx+c$ leképezést \;\;(ekkor $q = ||B||$, azonos normában)
+		\2 Elégséges feltétel kontrakcióra bármilyen kezdőértékkel: $||B|| < 1$
+		\2 Szükséges és elégséges feltétel, bármilyen kezdőérték: $\varrho(B) < 1$
+		\2 Ha a fenti állítások igazak, akkor $\forall x^{(0)}$ esetén kontrakció
+		\2 Ha nem igazak, akkor is létezhez $x^{(0)}$, amire kontrakció
+\end{outline}
+
+\subsection{Hibabecslés}
+
+\begin{outline}
+	\1 Ugyan azt a normát használjuk, mint a kontrakciós együtthatóhoz
+	\1 $||x^{(k)} - x^*|| \le q^k * ||x^{(0)} - x^*||$
+	\1 $||x^{(k)} - x^*|| \le \frac{q^k}{1-q} * ||x^{(1)} - x^{(0)}||$
+	\1 Hány ($k$) lépést kell tenni adott ($\alpha$) pontossághoz adott $x_0$ esetén?
+		\2 $||x^{(k)} - x^*|| \le \frac{q^k}{1-q} * ||x^{(1)} - x^{(0)}|| \le \alpha$
+		\;\; (itt $q$, $x^{(1)}$, $x^{(0)}$, $\alpha$ ismert)
+		\2 Rendezve: $||x^{(k)} - x^*|| \le q^k \le ... * \alpha
+		\implies k \ge \log_{q}(... * \alpha)$
+			\3 Reláció megfordult, mert $q < 1$
+\end{outline}
+
+\pagebreak
+
+\section{Jacobi-iteráció}
+
+\begin{outline}
+	\1 Eredeti feladat: $Ax=b$
+	\1 Legyen $A = L+D+U$ (semmi köze az LDU-felbontáshoz)
+	\1 Iteráció: $x^{(k+1)} = -D^{-1}(L+U)x^{(k)}+D^{-1}b = B_J * x^{(k)} + c_J$
+	\1 Koordinátás, komponensenkénti alak
+		\2 $x_i^{(k+1)} = \frac{-1}{a_{ii}} (\sum_{j=1,j \ne i}^{n} a_{ij} x_j^{(k)} - b_i)$
+		\2 pl. $x_2^{(1)} = \frac{-1}{a_{22}} (a_{21}x_1^{(0)} + a_{23}x_3^{(0)} - b_2)$
+	\1 Reziduum vektoros alak
+		\2 $r^{(0)} = b - Ax^{(0)}$ és $k=1,...$
+		\2 $s^{(k)} = D^{-1} r^{(k)}$
+		\2 $x^{(k+1)} = x^{(k)} + s^{(k)}$ és $r^{(k+1)} = r^{(k)} - As^{(k)}$
+	\1 Ha $A$ szig. diag. dom. a soraira, akkor az iteráció mindig konvergens
+	\1 Relaxált, csillapított Jacobi-iteráció: nem szokott lenni ZH-ban
+\end{outline}
+
+\pagebreak
+
+\section{Gauss-Seidel-iteráció}
+
+\begin{outline}
+	\1 Eredeti feladat: $Ax=b$
+	\1 Legyen $A = L+D+U$ (semmi köze az LDU-felbontáshoz)
+	\1 Iteráció: $x^{(k+1)} = -(L+D)^{-1}Ux^{(k)}+(L+D)^{-1}b = B_S * x^{(k)} + c_S$
+	\1 Koordinátás, komponensenkénti alak
+		\2 $x_i^{(k+1)} = \frac{-1}{a_{ii}} (
+		\sum_{j=1}^{i-1} a_{ij} x_j^{(k+1)}
+		+ \sum_{j=i+1}^{n} a_{ij} x_j^{(k)}
+		- b_i)$
+		\2 pl. $x_2^{(1)} = \frac{-1}{a_{22}} (a_{21}x_1^{(1)} + a_{23}x_3^{(0)} - b_2)$
+	\1 Reziduum vektoros alak
+		\2 $r^{(0)} = b - Ax^{(0)}$ és $k=1,...$
+		\2 $s^{(k)} = (D+L)^{-1} r^{(k)}$
+		\2 $x^{(k+1)} = x^{(k)} + s^{(k)}$ és $r^{(k+1)} = r^{(k)} - As^{(k)}$
+	\1 Az iteráció minden $x^{(0)}$ esetén konvergens, ha
+		\2 ha $A$ szigorúan diagonális domináns a soraira
+		\2 vagy ha $A$ pozitív definit mátrix
+	\1 Csillapított, relaxált Gauss-Seidel-iteráció: nem szokott lenni ZH-ban
+\end{outline}
+
+\pagebreak
+
+\section{Richardson-iteráció}
+
+\begin{outline}
+	\1 Legyen $A$ egy pozitív definit mátrix és $p \in \mathbb{R}$
+		\2 Pozitív definit $\Leftrightarrow$ minden sajátértéke pozitív
+	\1 Eredeti feladat: $Ax=b \implies p*Ax = p*b$
+	\1 Iteráció: $x^{(k+1)} = (I-pA) x^{(k)} + pb = B_{R(p)} * x^{(k)} + c_{R(p)}$
+	\1 Reziduum vektoros alak
+		\2 $r^{(0)} = b - Ax^{(0)}$ és $k=1,...$
+		\2 $s^{(k)} = p r^{(k)}$
+		\2 $x^{(k+1)} = x^{(k)} + s^{(k)}$ és $r^{(k+1)} = r^{(k)} - As^{(k)}$
+\end{outline}
+
+\subsection{Konvergencia}
+
+\begin{outline}
+	\1 Legyenek $A$ sajátértékei $m = \lambda_1 \le ... \le \lambda_n = M$
+	\1 $R(p)$ pontosan $p \in (0; \frac{2}{M})$ esetén konvergens ($\forall x^{(0)}$)
+	\1 Optimális paraméter: $p_0 = \frac{2}{M+m}$
+		\2 Ekkor $q = \frac{M-m}{M+m} = ||B_{R(p_0)}||_2 = \varrho(B_{R(p_0)})$
+\end{outline}
+
+\pagebreak
+
+\section{Részleges LU-felbontás, ILU-iteráció}
+
+\subsection{ILU-felbontás}
+
+\begin{outline}
+	\1 $J$: (mátrix) pozícióhalmaz, $(i,i) \notin J$
+	\1 $(i,j) \in J \implies l_{ij} = u_{ij} = 0$
+	valamint $(i,j) \notin J \implies a_{ij} = (LU)_{ij}$
+		\2 Azaz rendes $A=LU$ felbontás, de pár elem 0
+	\1 Felbontás algoritmusa ($L$, $U$ és $Q$ kiszámolása)
+		\2 $k=1,...,n-1$ és $\widetilde{A}_1 = A$
+		\2 $\widetilde{A}_k = P_k - Q_k$
+			\3 $k$-adik sor/oszlop van $J$-ben: $Q$-ba beletesszük $A$ azon pozíciójának $-1$-szeresét és $P$-ban 0-ra állítjuk az értéket
+		\2 $\widetilde{A}_{k+1} = L_k P_k$
+			\3 GE-vel elimináljuk $P$ $k$-adik oszlopát, "lépést" $L_k^{-1}$-be mentjük
+			\3 Gyakorlatilag LU-felbontás: $\widetilde{A}_{n} \sim U$
+			\3 Tömör írásmódra is van lehetőség: $A$, $L$, $P$ egyben
+	\1 Felbontás befejezése (cél: $A = LU-Q$)
+		\2 $U = \widetilde{A}_n$
+		\2 $L = L_1^{-1} * ... * L_{n-1}^{-1}$ (összepakolás)
+		\2 $Q = Q_1 + ... + Q_{n-1}$ (összepakolás)
+\end{outline}
+
+\subsection{ILU-iteráció}
+
+\begin{outline}
+	\1 Eredeti feladat: $Ax=b$
+	\1 Legyen $A = P-Q$ és $P=LU$
+	\1 Iteráció: $x^{(k+1)} = P^{-1} Q x^{(k)} + P^{-1} b = B_{ILU} * x^{(k)} + c_{ILU}$
+	\1 Koordinátás, komponensenkénti alak: nem volt a dián
+	\1 Reziduum vektoros alak
+		\2 $r^{(0)} = b - Ax^{(0)}$ és $k=1,...$
+		\2 $s^{(k)} = P^{-1} r^{(k)}$
+		\2 $x^{(k+1)} = x^{(k)} + s^{(k)}$ és $r^{(k+1)} = r^{(k)} - As^{(k)}$
+\end{outline}
+
+\pagebreak
+
+\section{Kerekítési hibák hatása az iterációkra}
+
+\begin{outline}
+	\1 Legyen $\epsilon$ a lépésenkénti hiba felső korlátja: $||\epsilon^{(k)}|| \le \epsilon$
+	\1 Ekkor $\lim\limits_{k \to \infty} ||z^{(k)}|| \le \frac{\epsilon}{1 - ||B||}$
+\end{outline}
+
+\section{Maradék tananyag}
+
+\begin{outline}
+	\1 Nemlineáris dolgok és 12. előadás anyaga: rendes ZH-n nem lesz, de javító ZH-n és vizsgán lesz
+
+\end{outline}
+
+\pagebreak
+
+\section{ZH2 összefoglalás}
+
+\subsection{Normák, spektrálsugár, kondíciószám}
+
+\begin{outline}
+	\1 Manhattan norma: $||x||_1 = \sum_{i=1}^n |x_i|$
+	\1 Euklideszi norma: $||x||_2 = \sqrt{<x,x>} = \sqrt{x^Tx} = \sqrt{\sum_{i=1}^{n} x_i^2}$
+	\1 Csebisev norma: $||x||_\infty = \max |x_i|$
+	\1 p-norma: $||x||_p = (\sum_{i=1}^{n} |x_i|^p)^{1/p}$ \;\; ($1 \le p < \infty$)
+	\1 Frobenius-norma (nem indukált, 2-höz illeszkedő): $||A||_F = \sqrt{ \sum_{i=1}^{n} \sum_{j=1}^{n} |a_{ij}|^2 }$
+	\1 Oszlopnorma: $||A||_1 = \max_{j=1}^n \sum_{i=1}^{n} |a_{ij}|$ \;\; (oszlop szummák maximuma)
+	\1 Sornorma: $||A||_\infty = \max_{i=1}^n \sum_{j=1}^{n} |a_{ij}|$ \;\; (sor szummák maximuma)
+	\1 Spektrálnorma: $||A||_2 = \sqrt{\max_{i=1}^{n} \lambda_i (A^T A)} = \sqrt{\varrho(A^TA)}$
+		\2 Spektrálsugár: $\varrho(A) = \max_{i=1}^{n} |\lambda_i (A)|$
+		\2 Szimmetrikus mátrix esetén: $||A||_2 = \varrho(A)$
+\end{outline}
+
+\subsubsection{Tulajdonságok, egyebek}
+
+\begin{outline}
+	\1 Normák ekvivalensek: $\exists c_1,c_2: \;\; c_1*||x||_b \;\le\; ||x||_a \;\le\; c_2*||x||_b$
+	\1 Indukált norma, természetes mátrixnorma: $||A|| = \sup \frac{||Ax||_v}{||x||_v}$ \; ($x \ne 0$)
+	\1 Illeszkedő norma: $||Ax||_v \le ||A|| * ||x||_v$
+
+\end{outline}
+
+\subsubsection{Vektor- és mátrixnormák axiómái}
+
+\begin{outline}
+	\1 $||x|| \ge 0$
+	\;\;\;\;\;\;\;\;\;\;\;\;\;\;\;\;\;\;\;\;\;\;\;\;
+	$\circ$ $||x|| = 0 \Leftrightarrow x = 0$
+	\1 $||\lambda * x|| = |\lambda| * ||x||$
+	\;\;\;\;\;\;\;
+	$\circ$ $||x+y|| \le ||x|| + ||y||$
+	\1 Csak mátrixnormákhoz: $||A*B|| \le ||A|| * ||B||$
+\end{outline}
+
+\subsubsection{Kondíciószám}
+
+\begin{outline}
+	\1 $\kappa(A) = cond(A) = ||A||*||A^{-1}||$
+	\1 $A$ szimmetrikus $\implies cond_2(A) = \frac{\max |\lambda_i (A)|}{\min |\lambda_i (A)|}$
+\end{outline}
+
+\pagebreak
+
+\subsection{Iterációkról általánosságban}
+
+\begin{outline}
+	\1 $x^{(k+1)} = \varphi(x^{(k)}) = B x^{(k)} + c$ ahol $B$ az átmenet mátrix és $x^{(0)}$ tetszőleges
+	\1 $Ax=b \;\;\Leftrightarrow\;\; (I-B)x = c \;\;\Leftrightarrow\;\; x = Bx+c$
+	\1 $q \in [0,1)$ esetén $\varphi$ kontrakció, $! \exists$ fixpont ($x=\varphi(x)$), minden $x^{(0)}$ jó
+	\1 Elégséges feltétel: $q = ||B|| < 1$
+	\1 Szükséges és elégséges feltétel: $q = \varrho(B) < 1$
+	\1 Hibabecslés: $||x^{(k)} - x^*|| \le \frac{q^k}{1-q} * ||x^{(1)} - x^{(0)}||$ \;\; (illeszkedő normában)
+\end{outline}
+
+\subsection{Jacobi-iteráció}
+
+\begin{outline}
+	\1 $A = L+D+U$ \;\; (nem LDU-felbontás)
+	\1 Vektoros alak: $x^{(k+1)} = -D^{-1}(L+U)x^{(k)}+D^{-1}b = B_J * x^{(k)} + c_J$
+	\1 Koordinátás alak: $x_i^{(k+1)} = \frac{-1}{a_{ii}} (\sum_{j=1,j \ne i}^{n} a_{ij} x_j^{(k)} - b_i)$
+	\1 $A$ szig. diag. dom. soraira $\implies$ mindig konvergens
+\end{outline}
+
+\subsection{Gauss-Seidel-iteráció}
+
+\begin{outline}
+	\1 $A = L+D+U$ \;\; (nem LDU-felbontás)
+	\1 Vektoros alak: $x^{(k+1)} = -(L+D)^{-1}Ux^{(k)}+(L+D)^{-1}b = B_S * x^{(k)} + c_S$
+	\1 Koordinátás alak: $x_i^{(k+1)} = \frac{-1}{a_{ii}} (
+	\sum_{j=1}^{i-1} a_{ij} x_j^{(k+1)}
+	+ \sum_{j=i+1}^{n} a_{ij} x_j^{(k)}
+	- b_i)$
+	\1 $A$ szig. diag. dom. soraira vagy $A$ poz. definit $\implies$ mindig konvergens
+\end{outline}
+
+\subsection{Richardson-iteráció}
+
+\begin{outline}
+	\1 Feltétel: $A$ pozitív definit mátrix: $0 < m = \lambda_1 \le ... \le \lambda_n = M$
+	\1 $Ax=b \implies p*Ax = p*b$ \;\; ($p \in \mathbb{R}$)
+	\1 Vektoros alak: $x^{(k+1)} = (I-pA) x^{(k)} + pb = B_{R(p)} * x^{(k)} + c_{R(p)}$
+	\1 $R(p)$ konvergens minden $x^{(0)}$-ra \;\;$\Leftrightarrow$\;\; $p \in (0; \frac{2}{M})$
+	\1 Optimális $p$: $p_0 = \frac{2}{M+m}$ $\implies$
+	$q = \frac{M-m}{M+m} = ||B_{R(p_0)}||_2 = \varrho(B_{R(p_0)})$
+\end{outline}
+
+\pagebreak
+
+\subsection{ILU felbontás, ILU-iteráció}
+
+\subsubsection{ILU-felbontás}
+
+\begin{outline}
+	\1 $J$ pozícióhalmaz, $(i,i) \notin J$
+	\1 $k=1,..,n$
+	\1 $A \implies \widetilde{A}_1 = A$
+	\1 $\widetilde{A}_k \implies \widetilde{A}_k = P_k - Q_k$
+	\;\; hogy ha $J$-ben van k-adik oszlop/sor pozíció:
+		\2 $Q$-ba beletesszük az érték $-1$-szeresét
+		\2 $P$-ben 0-ra állítjuk azon értéket
+	\1 GE-vel $P$ k-adik oszlopának eliminációja: $\widetilde{A}_{k+1} = L_k P_k$
+		\2 Gyakorlatilag LU-felbontás, tömör írásmódra is van lehetőség
+	\1 Felbontás befejezése (cél: $A = LU-Q$)
+		\2 $U = \widetilde{A}_n$
+		\2 $L = L_1^{-1} * ... * L_{n-1}^{-1}$ (összepakolás)
+		\2 $Q = Q_1 + ... + Q_{n-1}$ (összepakolás)
+\end{outline}
+
+\subsubsection{ILU-iteráció}
+
+\begin{outline}
+	\1 $A=P-Q$ és $P=LU$
+	\1 Vektoros alak: $x^{(k+1)} = P^{-1} Q x^{(k)} + P^{-1} b = B_{ILU} * x^{(k)} + c_{ILU}$
+\end{outline}
+
+\end{document}
diff --git a/oprend/README.md b/oprend/README.md
new file mode 100644
index 0000000..014d1d3
--- /dev/null
+++ b/oprend/README.md
@@ -0,0 +1,12 @@
+**Képzés:** ELTE IK Proginf BSc, Szoftvertervező (B) szakirány (kezdés éve: 2020)  
+**Tárgy neve:** Operációs rendszerek  
+**Tárgy kódja:** IP-18OPREG
+
+Az erről a tárgyról szóló jegyzet több okból is rendhagyó:
+ - Csak a gyakorlati anyagrészről készült jegyzet.
+ - A jegyzet nem egy LaTeX fájl PDF-ként exportálva, hanem egy TXT fájl.
+ - A jegyzet mellé készült egy könyvtárként szolgáló C forrásfájl, ami támpontul tud szolgálni a gyakorlati zárthelyihez.
+
+Linkek:
+ - [Jegyzet link](oprend-gyak.txt)
+ - [template.c forrásfájl link](template.c)
diff --git a/oprend/oprend-gyak.txt b/oprend/oprend-gyak.txt
new file mode 100644
index 0000000..4491ce8
--- /dev/null
+++ b/oprend/oprend-gyak.txt
@@ -0,0 +1,446 @@
+Struct:
+	typedef struct { long cat; char message[50]; } msg_t;
+	msg_t x = { 5, "CYCSS7" };
+
+Manuál:
+	általában: `man fvnév` vagy `man fvnév.#` (#=2,3)
+
+string.h:
+	strcpy: copy
+	strcat: append
+	strlen: length
+	strcmp: compare
+	string literál: array-nak adva mutable, egyébként immutable
+
+Memóriafoglalás:
+	malloc (sikertelen -> NULL-t ad vissza)
+	realloc (sikertelen -> NULL-t ad vissza -> temp-be realloc-oljunk először, hogy ne vesszen el az előző alloc)
+	free (null -> nem csinál semmit)
+Memóriamozgatás:
+	memcpy: közvetlen
+	memmove: először átmeneti helyre másol -> használni akkor, amikor az src és dst átfedésben van
+
+Paraméterek:
+	int main(int argc, char *argv[]) { ... }
+	argv[0]: program neve  => argc mindig legalább 1
+
+Standard IO:
+	scanf és printf különböző formátumot használ, pl. long long int-hez
+	scanf
+		max adott mennyiség beolvasása: scanf("%20s", inputOfLength21);
+		max n karakter beolvasása, sor maradékának eldobása:
+			int read;
+			scanf("%20[^\n]%n", array, &read); //%n: mennyi karaktert olvastam ki
+			char temp;
+			do {
+				scanf("%c", &temp);
+			} while (temp != '\n' && temp != EOF);
+		' %s': eldobja a whitespace-t a szöveg előtt
+	printf
+
+Random:
+	rand(): egész, [0, MAX_RAND]
+	rand() % B: egész, [0, B-1]
+	rand() % (B-A+1) + A: egész, [A, B]
+	srand(time(NULL));
+
+Felhasználó:
+	getpwuid, getpwnam: adatok lekérdezése
+
+Idő:
+	time(NULL): pillanatnyi idő
+	ctime: time_t -> szöveg, végén soremelés
+	localtime: time_t t-> tm
+	struct tm: tm_sec, tm_mday, tm_mon, tm_yday, ....
+
+Fájlrendszer:
+	stat: fájl adatainak lekérdezése (man stat.2)
+Könyvtár bejárás:
+	opendir
+	readdir
+	closedir
+Fájlkezelés:
+	access: fájlhoz való hozzáférés ellenőrzése: if (access(filename, F_OK | R_OK | W_OK) != 0) { perror("File access error"); exit(1); }
+Fájlkezelés stream függvényekkel: (ritkán használt)
+	Mintafüggvények (open_fopen.c): use_fopen_text(), use_fopen_bin()
+	FILE*, fopen, fclose
+	szöveges: fprintf, fputc, fputs, fgetc, fgets
+		fprintf: mint a printf
+		fgets: új sorig olvas, de az is benne van az eredményben; NULL ha 0 karaktert tudott kiolvasni (pl. EOF miatt)
+	bináris: fwrite, fread
+		használat tömbök esetén: fread/fwrite(array, sizeof(array[0]), sizeof(array)/sizeof(array[0]), file)
+		használat egye elem esetén: fread/fwrite(&value, sizeof(value), 1, f)
+	fopen: igazzá válik az első EOF miatt sikertelen beolvasás után
+		mód: r (olvasás), r+ (olvasás+írás, elejéről)
+		     w (írás, truncate/create), w+ (olvasás+írás, truncate/create)
+			 a (append, create), a+ (olvasás+append, create)
+	    visszatérési érték: fájl mutató vagy NULL (hiba)
+	fclose: EOF-t ad vissza, ha hiba
+	feof: fájl végénél járunk-e, azaz elértük-e a fájl végét
+	clearerr: hiba bitek hamissá tétele, pl. írás előtt
+	fseek: file író/olvasó mutató mozgatása, visszaadja az abszolút pozíciót (END esetén negatív pozíció kell)
+
+Fájlkezelés rendszerhívásokkal: EZT JAVASOLT HASZNÁLNI
+	use_open_bin(): bináris MINTAFÜGGVÉNY
+	int fileazonosító
+	open:
+		Egyik ezek közül kötelező: O_RDONLY, O_WRONLY, O_RDWR
+		3 paraméteres O_CREAT vagy O_TMPFILE esetén, mód a chmod, pl.: 0644
+		nem létezik, létrehozza; létezik, hiba: O_CREAT | O_EXCL
+		nyitáskor nullázás: O_TRUNC
+	close
+	read, write:
+		tömb változó: read/write(f, array, sizeof(array))
+		scalar változó: read/write(f, &value, sizeof(v))
+		string esetén: sizeof(array) helyett strlen(pointer)
+		hiba esetén -1-et ad vissza
+	lseek: mint az fseek
+Fájl zárolás:
+	fcntl(fileid, F_SETLKW/F_SETLK, &flock): fájl zárolás (fcontrol)
+		F_SETLKW: vár, amíg eltűnik a lock
+		F_SETLK: visszatérési érték -1, ha sikertelen
+	struct flock:
+		short l_type: F_RDLCK, F_WRLCK, F_UNLCK
+		short l_whence: SEEK_SET, SEEK_CUR, SEET_END (általában SEEK_SET)
+		off_t l_start: lock kezdőpozíciója (általában 0)
+		off_t l_len: lock-olt bájtok száma, 0->összes
+		off_t l_pid: lock-oló folyamat PID-je (nem kötelező megadni)
+
+Hibakezelés:
+	errno: változó, legutóbb bekövetkezett hiba
+	perror: errno-hoz tartozó hibaüzenet kiírása, pl.: if (x == NULL) { perror("Error opening file\n"); }
+
+Folyamatkezelés:
+	pid_t ~ int
+	fork(): szülő folyamatban >0 vagy -1, ha hiba, gyerekben 0
+	getpid: saját pid
+	getppid: szülő folyamat pid-je
+		ha a szülő már befejeződött: rendszerfüggő??? megváltozik a szülője a gyakorlatban
+	int wait(&status): bármelyik (közvetlen) gyerek befejezésére vár
+		nem vár semennyit, ha nincsen futó gyerek
+		&status lehet NULL
+	int waitpid(pid, &status, opt)
+		adott (közvetlen) gyerek jelzésére vár
+		pid=-1 -> bármelyik
+		opt: melyik jelzésre, 0->befejezés
+	sleep, usleep: szignál-t vár, max X ideig
+		NE HASZNÁLJUK HA KÜLÖN NEM KÉRTEK MEG RÁ
+	execv, execl: másik program betöltése, eredeti PID megtartása
+		parancs utáni kód soha nem fog lefutni
+		execv: paraméterek egy string tömbben
+		execl: paraméterek felsorolva szerepelnek, null-al lezárva
+			példa: execl("/bin/ls", "ls", NULL);
+		Első paraméter: futtatandó fájl neve
+	system(char*): létrehoz gyereket, vele végrehajtat egy külső programot, de MEGVÁRJA (NEM párhuzamos)
+
+Szignálok:
+	kill: szignál küldése
+		pid=0 -> azonos csoportban lévők (szülő+gyerek)
+		pid=-1 -> mindenki, aki felé van jogunk
+		Linux parancsként: kill -SIGTERM <pid>
+	raise: önmagunknak szignál küldése
+	pause: vár egy új szignálra (már megérkezettek nem érdekli őt)
+		blokkolt szignált se kap meg
+		NE HASZNÁLJUK HA KÜLÖN NEM KÉRTEK MEG RÁ
+			"megoldás": wait(NULL)-at használhatok, ami interrupt-olva lesz szignál esetén
+	sighandler_t signal(int signum, sighandler_t handler): szignálkezelő megadása
+		signum: lista: kill -l, de vannak konstansok
+		handler: függvénypointer (név) / SIG_IGN (ignore) / SIG_DFL (default)
+		SIG_IGN: nem azonos az üres kezelővel: így pl. a pause soha nem kapja meg a signalt
+	sighandler_t: void handler(int signum) {...}
+	psignal: mint a perror
+	SIGKILL, SIGSTOP: kivétel, ezeket nem lehet befolyásolni
+
+Szignál halmazok, szignál maszkok:
+	return majdnem mindegyiknél: 0 (siker) vagy -1 (hiba)
+	sigset_t: szignál halmaz
+	int sigemptyset(sigset_t *set): üres sigset
+		hasonlóan: sigfillset
+	int sigaddset(sigset_t *set, int signum): sigset-hez hozzáadás
+		hasonlóan: sigdelset
+	int sigismember(const sigset_t *set, int signum): 0 (nem), 1 (igen), vagy -1 (hiba)
+	int sigprocmask(int how, const sigset_t *set, sigset_t *oldset)
+		lehet NULL: oldset vagy set
+		how=SIG_BLOCK: blokkolt = régi unió új
+		how=SIG_UNBLOCK: blokkolt = régi setminus új
+		how=SIG_SETMASK: blokkolt = új
+	int sigsuspend(const sigset_t *mask): vár amíg bármilyen nem blokkolt szignál meg nem érkezik
+		return mindig -1 (vagy terminál a processz)
+		szignál maszkot lecseréli az új maszkra átmenetileg, visszatérés után visszaáll a régi szignál maszk
+		szignál maszkban lévő értékek = mi van blokkolva
+	Szignálok megérkezésének sorrendje nem definiált (kivéve: real-time szignálok)
+	Egy szignál csak egyszer érkezhet meg blokkolás után (nincs queue, csak flag)
+	Real-time (valós idejű) szignálok: ha fontos, hogy annyi érkezzen, ahány küldve volt
+		SIGRTMIN és SIGRTMAX közé eső szignálok (konkrét szám változhat!)
+		Prioritásosak: SIGRTMAX a fontos, ez mindent beelőz (a nem realtime-ot is, ők a SIGRTMIN alatt vannak)
+		Ugyan az a szignál többször is megérkezhet blokkolás után (van priority queue)
+		Kötelező gcc kapcsoló ilyenkor: -lrt (gcc x.c -lrt)
+		Más különbség nincsen: egyébként hasonló a user defined szignálokhoz
+
+Szignálok összetett handler-rel:
+	void handler(int signo, siginfo_t* info, void* context) {...}
+	struct siginfo_t:
+		si_code (ki küldte): SI_USER, SI_QUEUE (sigqueue), SI_TIMER, SI_MESGQ (üzenetsor)
+		si_pid: küldő PID-je
+		si_value: sival_int vagy sival_ptr (ez egy union)
+	struct sigaction:
+		sa_sigaction: kezelő függvény (pointer) vagy SIG_DFL (default) vagy SIG_IGN (ignore)
+		sa_mask (sigset_t): kezelő függvény  végrehajtása során mi más legyen még eddigieken felül blokkolva
+			handler-ben blokkolva van: folyamatban blokkolva volt + kapott signal + itt megadott signalok
+		sa_flags (bitflag): SA_SIGINFO-t kell megadni, ha összetett handlert akarunk használni (egyébként 0 és alap handler lesz)
+	int sigaction(int signum, struct sigaction *act, struct sigaction *oldact): handler regisztrálása
+		oldact lehet NULL (nem is volt róla szó)
+		visszatérési érték: 0 (siker), -1 (hiba)
+	int sigqueue(pid_t pid, int sig, union sigval value): kill-hez hasonlít, de extra adotot is küld
+		visszatérési érték: 0 (siker), -1 (hiba)
+
+Szignál kezelése folyamatból (külső handler helyett):
+	int sigwaitinfo(sigset_t *set, siginfo_t *info)
+		set-ben lévő szignálra vár
+		visszatérési érték: érkezett szignál száma vagy -1 (hiba)
+		ilyenkor a handler nem fut le, de szükséges: a default handler megöli a folyamatot
+	int sigtimedwait(sigset_t *set, siginfo_t *info, struct timespec *timeout)
+		max X ideig vár szignálra (azon kívül: ~ sigwaitinfo)
+		visszatérési érték lehet még -1, ha timeout
+		0 ideig várakozás => egyből visszatér (dokumentált működés)
+	struct timespec: tv_sec, tv_nsec (hasonlít struct timeval-ra)
+
+Időzítés:
+	egy programban csak egyfélét szabad használni
+	szignált küld (saját magának) amikor lejár az idő
+	máshogy műkdöik signal érkezés esetén, mint a sleep (????)
+	egyszerű: alarm(unsigned int seconds) -> SIGALRM megadott idő után
+	ismétlődő:
+		struct timeval: tv_sec, tv_usec (összegük számít)
+		struct itimerval (ezek timeval típusúak): it_interval (0 -> egyszeri), it_value (0 -> leállítás)
+		setitimer(ITIMER_XYZ, struct itimerval *new_value, struct itimerval *old_value)
+			ITIMER_REAL -> SIGALRM, ITIMER_VIRTUAL -> SIGVTALARM
+			old_value lehet NULL
+		getitimer(struct itimerval *curr_value): hol tart az időzítő?
+		visszatérési érték: 0 (siker), -1 (hiba)
+	tetszőleges szignál és érték küldése:
+		visszatérési értékek: 0 (siker), -1 (hiba)
+		timer_create(CLOCK_REALTIME, struct sigevent *sevp, timer_t *timerid)
+			timerid: kiementi változó
+		struct sigevent:
+			sigev_notify: SIGEV_NONE (semmi nem történik idő végén), SIGEV_SIGNAL
+			sigev_signo: melyik szignált küldje
+			sigev_value: szignállal küldendő union
+		struct itimerpsec (adataggjai timespec): it_interval (köztes idő), it_value (első előtti várakozás)
+		timer_settime(timer_t timerid, int flags, struct itimerspec *new_value, struct itimerspec *old_value)
+			beállítja és elindítja az időzítőt
+			old_value: lehet NULL
+			flags: hagyjam üresen, újraindítás esetén nullázás: TIMER_ABSTIME
+		timer_gettime(timer_t timerid, struct itimerspec *curr_value)
+		timer_delete(timer_t timerid)
+
+Cső (pipe):
+	Névtelen cső: pipe(int pipefd[2])
+		fork előtt kell meghívni
+		0. index: olvasásra fileid, használat: read
+			mindaddig vár, amíg van benne adat és nem lett lezárva a cső
+		1. index: írásra fileid, használat: write
+			kevesebbet írt ki, mint akart: be lett zárva a cső
+		visszatérési érték: 0 (siker), -1 (hiba)
+		close: mindkét végét le kell zárni
+	Nevesített cső (named pipe):
+		konkrét fájlba írja a dolgokat, szóval akár 1 nap késéssel is mehet az olvasás
+		használat: szülő létrehozza
+		mkfifo(fájlnév, engedélyek): létrehozás
+			megengedett könyvtár (opsys szerveren): /tmp/-ben
+			engedélyek: S_IRUSR, S_IWUSR, 0666, S_I[R|W][USR|GRP|OTH]
+			utána minden processzben: meg kell nyitni (open) és le kell zárni (close)
+			O_RDONLY: O_WRONLY: open addig vár, amíg a másik irány nem nyílt meg (O_RDWR az nem)
+			read, write ugyan úgy működik (csak várakoznak, amíg az olvasás/írás teljesen végbement, kivéve az O_RDWR pipe)
+			hibát dob, ha már létezik a fájl
+		unlink(fájlnév): cső törlése
+
+Pollolás (poll):
+	pollfd:
+		fd: cső (file) azonosító
+		events: figyelt esemény, pl.: POLLIN (van olvasható adat), POLLOUT (lehet írni)
+		revents: bekövetkezett esemény, pl.: POLLHUP (olvasási vég lezárva)
+	int poll(struct pollfd *fds, nfds_t nfds, int timeout):
+		fds egy tömb, ndfs pedig a tömb mérete
+		ha a bemenet POLLIN és a kimenet is POLLIN, akkor van olvasható adat
+			ha a bemenet POLLIN, de a kimenet nem: kiolvasva a revents-et megkapom, hogy miért nem olvasható
+		visszatérési érték: miért lépünk tovább (ezek egyikéig vár, szóval alapból vár pozitív válaszig)
+			pozitív: van pozitív válasz
+			0: időtúllépés
+			negatív: szignál
+	ppoll: átmenetileg lecseréli a szignál maszkot, azon kívül ugyan az
+
+Pollolás #2 (select):
+	fd_set
+		void FD_ZERO(fd_set *set): set kiürítése
+		void FD_SET/FD_CLR(int fd, fd_set *set): setbe hozzáadás/törlés
+		int FD_ISSET(int fd, fd_set *set)
+	select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout)
+		ndfs: MAX(max(writendfs), max(readndfs)) + 1   (nem mondta el, hogy miért)
+		exceptndfs: nem foglalkozunk vele, TOOD lehet-e NULL
+		visszatérési érték: mint a poll-nál, ugyan úgy várakozik is
+		azt hagyja benne a készletben, amelyikre pozitív a válasz
+
+IPC (InterProcess Communication), System V
+	3 rész: message queues, shared memory segments, semaphore sets
+	Parancssorból:
+		ipcs: listázás
+		ipcrm -a: töröl minden üzenetsort, osztott memóriát, szemafort
+			opsys szerveren csak a sajátunkat törli (többire hibát ad)
+	key_t ftok(char* path, int id): kulcs generálás
+		szöveg (valid path, pl. /tmp) és szám (8 bit) alapján generálja a kulcsot
+		valid path: egyes parancsokhoz létező kell, egyesek nem létezőt is elfogadnak
+		egyszerű valid path: argv[0]
+		alternatíva: IPC_PRIVATE
+
+System V üzenetsorok:
+	System V IPC-s shell parancsok használhatók -q/-Q kapcsolóval
+		ipcs: listázás
+		ipcrm -q <azon>: törlés
+		ipcmk -Q: készítés
+	ez is a POSIX része: POSIX átvette
+	int msgget(key_t key, int msgflg): létrehozás/csatlakozás
+		kulcs: ftok-kal generált kulcs vagy IPC_PRIVATE (automatikus generálás)
+		flag: meglévő esetén 0, létrehozáshoz IPC_CREAT és jogosultságok (pl. 0666)
+		visszatérési érték: -1 (hiba) vagy egy id
+	törlés: msgctl(<mq_id>, IPC_RMID, NULL)
+		visszatérési érték: 0 vagy -1 (hiba)
+	üzenet struktúra: nem kötött, én hozom létre a struktot, de kötelezően 2 adattag
+		első addattag: long, 'msgtype', 'message type'
+		második adattag: bármi, payload
+	int msgsnd(int msqid, void* msgp, size_t msgsz, int msgflg): küldés
+		stuktúra memóriacímét kell átadni
+		második adattag méretét kell átadni (!!!), azaz sizeof(my_struct.masodik)
+		flag: 0 működik
+		visszatérési érték: 0 vagy -1 (hiba)
+	ssize_t msgrcv(int msqid, void* msgp, size_t msgsz, long msgtyp, int msgflg): fogadás
+		első három paraméter: mint küldésnél
+		msgtyp == 0 -> FIFO-ként következő bármilyen kategóriájú üzenet kiolvasása
+		msgtyp != 0 -> FIFO még mindig, de filter-elünk adott kategóriára
+		flag: 0 működik
+		visszatérési érték: második (!!!) adattagba beolvasott bájtok száma vagy -1 (hiba)
+
+POSIX prioritásos üzenetsorok:
+	man mq_overview
+	Kötelező gcc kapcsoló ilyenkor: -lrt (gcc x.c -lrt)
+	queue maximális mérete: 10
+	üzenet maximális mérete: 8192
+	mqd_t mq_open(char* name, int oflag, mode_t mode, struct mq_attr* attr): létrehozás/csalakozás
+		név: pl. /cycss7 ('/' jellel kezdődik, utána pedig csak karakterek)
+		flag: O_RDONLY vagy O_WRONLY vagy O_RDWR és ezen kívül lehet OR-onli...
+			O_CREAT: létrehozás
+			O_EXCL: létehozás legyen sikertelen, ha már létezik
+			O_NONBLOCK: létrehozáskor kell odaadni, ilyenkor írás/olvasás nem blokkol, hanem EAGAIN-nel fail-el
+		Ezek a paraméterek csak létrehozáskor kellenek:
+			mode: milyen jogokkal hozzuk létre, pl. 0666
+			mq_attr: NULL -> legtágabb, nem NULL -> szűkítés (max queue méret, stb)
+	prioritás: nagyobb szám a fontosabb, legalább 0-tól 31-ig szabályos
+	int mq_send(mqd_t mqdes, char* msg_ptr, size_t msg_len, unsigned int msg_prio): küldés
+		visszatérési érték: 0 vagy -1 (hiba)
+	ssize_t mq_receive(mqd_t mqdes, char* msg_ptr, size_t msg_len, unsigned int* msg_prio): fogadás
+		buffer mérete: állítólag legalább annyi, mint a message queue-ban beállított üzenet méret (alapból 8192)
+		msg_ptr: milyen prioritásút olvastunk (ez nem egy filter, hanem egy kimeneti változó)
+		visszatérési érték: beolvasott bájtok száma vagy -1 (hiba)
+	int mq_close(mqd_t mqdes): lekapcsolódás (üzenetsor még él)
+		visszatérési érték: 0 vagy -1 (hiba)
+	int mq_unlink(char* name): üzenetsor törlése
+		visszatérési érték: 0 vagy -1 (hiba)
+	int mq_notify(mqd_t mqdes, struct sigevent* sevp): szignált kapok, majd ha a sor üres volt ÉS új üzenet jött
+		NEM blokkol
+		csak egy feliratkozó lehet: új feliratkozás törli az előzőt
+		ha kaptam szignált, akkor a feliratkozás törlődik
+		nem kapok szignált, ha egy másik process kiolvassa az üzenetet (olvasás metódus meg van hívva és blokkol)
+		visszatérési érték: 0 vagy -1 (hiba)
+
+Osztott memória (IPC, System V):
+	System V IPC-s shell parancsok használhatók -m/-M kapcsolóval
+		ipcs: listázás
+		ipcrm -m <azon>: törlés
+		ipcmk -M <méret>: létrehozás
+	Foglalás működési
+		Foglalás laponként működik: 1 bájt foglalása esetén is 4096 bájt lesz felhasználva
+	int shmget(key_t key, size_t size, int shmflg): létrehozás, megnyitás
+		kulcs: mint eddig (ftok-kal generált kulcs vagy IPC_PRIVATE automatikus generáláshoz)
+		méret: kívánt méret (csatlakozáskor megadható kevesebb, mint amennyivel létre lett hozva)
+		flag: meglévő esetén 0, létrehozáshoz IPC_CREAT | <hozzáférési jogok>
+		visszatérési érték: -1 ha hiba, egyébként azonosító
+	int shmctl(int shmid, int cmd, struct shmid_ds* buf): törlés
+		cmd: IPC_RMID
+		buf: NULL
+		visszatérési érték: 0 vagy -1 (hiba)
+	void* shmat(int shmid, void* shmaddr, int shmflg): kapcsolódás
+		2. param: NULL
+		3. param: 0
+		visszatérési érték: -1 ha hiba, egyébként pointer memóriára
+	int shmdt(const void* shmaddr): lekapcsolódás
+		paraméter: shmat visszatérési értéke (memóriacím) (NEM pedig az id)
+		visszatérési érték: 0 vagy -1 (hiba)
+		nem történik semmi baj, ha nem csinálom meg
+
+Szemaforok (IPC, System V):
+	kritikus szakasz: amikor a folyamat közösen használt erőforrást manipulál
+	szemafor készletek vannak: egy azonosító alatt több szemafor
+		készlet helyett lehetne használni egyelemű "készleteket" is, csak kényelmetlen és kevésbé hatékony
+	System V IPC-s shell parancsok használhatók -s/-S kapcsolóval
+		ipcs: listázás
+		ipcrm -s <azon>: törlés
+		ipcmk -S <elemszám>: létrehozás
+	int semget(key_t key, int nsems, int semflg): létrehozás/csatlakozás
+		kulcs: mint eddig (ftok-kal generált kulcs vagy IPC_PRIVATE automatikus generáláshoz)
+		szemaforok száma: meglévő esetén 0 (bármi), létrehozáskor ahány szemafort szeretnénk (min. 1)
+		flag: meglévő esetén 0, létrehozáshoz IPC_CREAT | <hozzáférési jogok>
+		visszatérési érték: azonosító vagy -1 (hiba)
+	int semctl(int semid, int semnum, int cmd, ...): szemafor készlet vezérlése
+		"..." lehet üres vagy <érték>
+		semid: szemafor készlet (azonosító)
+		semnum: készleten belüli sorszám
+		parancsok:
+			IPC_RMID: szemafor készlet törlése (semnum nem számít)
+			SETVAL: értékadás (kell az <érték>), létrehozás után használjuk (inicializálás)
+			GETVAL: érték lekérdezés (nem volt erről szó gyakorlaton)
+		visszatérési érték: -1 ha hiba, egyébként 0 vagy valami speciális érték (parancstól függően)
+	int semop(int semid, struct sembuf* sops, size_t nsops): műveletek végrehajtása
+		tömbben található műveleteket sorban (!!!) végrehajtja
+			minden többelemű tömb hívás áttranszformálható egymás utáni egyelemű tömb hívásokká (csak kényelmetlen)
+		max 32 elemű lehet a tömb
+		visszatérési érték: 0 vagy -1 (hiba)
+		sembuf:
+			sem_num: készleten belül hányadik szemafor
+			sem_flg (short): alapból legyen 0
+				IPC_NOWAIT: ne várakozzunk műveletekkor, helyette legyen hiba
+				SEM_UNDO: folyamat terminálásakor a szemafor kerüljön visszavonásra
+			sem_op (short): művelet
+		művelet:
+			pozitív: növeli a szemafor értékét (soha nem várakozik)
+			0: addig vár, amíg 0 nem lesz a szemafor értéke (IPC_NOWAIT-tel nem kompatibilis)
+			negatív: vár, amíg nem levonható az (abszolút) érték (mert kevesebb a szemafor értéke, mint a művelet abszolút értéke)
+
+POSIX szemaforok:
+	szemaforok egyesével vannak, nem készletekben
+	fordításkor ez a kapcsoló kell: -pthread
+	int sem_init(sem_t* sem, int pshared, unsigned int value): névtelen létrehozása
+		sem: kimeneti paraméter
+		pshared: szálak közötti szemafor esetén 0, processz-ek közötti szemafor esetén 1 (nem0)
+		value: kezdeti érték
+		visszatérési érték: 0 vagy -1 (hiba)
+	int sem_destroy(sem_t* sem): névtelen törlése
+		visszatérési érték: 0 vagy -1 (hiba)
+	int sem_unlink(char* name): nevesített törlése
+		visszatérési érték: 0 vagy -1 (hiba)
+	sem_t* sem_open(char* name, int oflag, mode_t mode, unsigned int value): nevesített létrehozása
+		sem_open(név, mód, hozzáférési-engedélyek, kezdőérték)
+		név: pl. /cycss7 ('/' jellel kezdődik, utána pedig csak karakterek)
+		oflag: O_CREAT, stb.
+		mode: hozzáférési engedélyek, pl. 0666
+		value: kezdeti érték
+		visszatérési érték: szemafor mutató vagy SEM_FAILED (hiba)
+	sem_t* sem_open(char* name, int oflag): csatlakozás
+		oflag: 0
+		visszatérési érték: szemafor mutató vagy SEM_FAILED (hiba)
+	sem_t*: csak pointerként használjuk, nem használunk adattagokat
+	int sem_post(sem_t* sem): 1-gyel növelés
+		visszatérési érték: 0 vagy -1 (hiba, ilyenkor a szemafor nem változik)
+	int sem_wait(sem_t* sem): 1-gyel csökkentés; vár, ha a pillanatnyi érték 0
+		int sem_trywait(sem_t* sem): sem_wait, de hibával tér vissza várakozás helyett
+		int sem_timedwait(sem_t* sem, struct timespec* abs_timeout): sem_wait, de max X ideig vár
+		visszatérési érték: 0 vagy -1 (hiba, ilyenkor a szemafor nem változik)
diff --git a/oprend/template.c b/oprend/template.c
new file mode 100644
index 0000000..8e4826f
--- /dev/null
+++ b/oprend/template.c
@@ -0,0 +1,371 @@
+//A -lrt kapcsoló használata szükséges fordításkor
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <errno.h>
+#include <string.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <wait.h>
+#include <sys/time.h>
+#include <sys/ipc.h>
+#include <time.h>
+#include <sys/shm.h>
+#include <sys/sem.h>
+#include <semaphore.h>
+#include <poll.h>
+#include <mqueue.h>
+#include <sys/select.h>
+#include <sys/msg.h>
+#include <sched.h>
+#include <pwd.h>
+#include <dirent.h>
+#include <ctype.h>
+
+#define SIGNAL_GENERAL SIGRTMIN
+
+void signal_noop_handler(int signo, siginfo_t* info, void* context) {}
+
+void signal_register_noop_handler() {
+	struct sigaction sigact;
+	sigact.sa_sigaction = signal_noop_handler;
+	sigemptyset(&sigact.sa_mask);
+	sigact.sa_flags = SA_SIGINFO;
+	if (sigaction(SIGNAL_GENERAL, &sigact, NULL) != 0) {
+		perror("Nem sikerült noop handler regisztrálása");
+		exit(1);
+	}
+}
+
+void signal_modify_mask(int how) {
+	sigset_t set;
+	sigemptyset(&set);
+	sigaddset(&set, SIGNAL_GENERAL);
+	if (sigprocmask(how, &set, NULL) != 0) {
+		perror("Hiba szignál maszk beállítása során");
+		exit(1);
+	}
+}
+
+void signal_send(pid_t target, int payload) {
+	sigval_t sigv;
+	sigv.sival_ptr = 0; //zero-initialization: make Valgrind warning disappear
+	sigv.sival_int = payload;
+	if (sigqueue(target, SIGNAL_GENERAL, sigv) != 0) {
+		perror("Nem sikerült a szignál küldése");
+		exit(1);
+	}
+}
+
+int signal_wait() {
+	sigset_t set;
+	sigemptyset(&set);
+	sigaddset(&set, SIGNAL_GENERAL);
+	
+	siginfo_t info;
+	if (sigwaitinfo(&set, &info) == -1) {
+		perror("Nem sikerült a szignál fogadás");
+		exit(1);
+	} else {
+		return info.si_value.sival_int;
+	}
+}
+
+int file_open(char* path, int flags) {
+	int file = open(path, flags | O_CREAT, 0666);
+	if (file == -1) {
+		perror("Nem sikerült megnyitni a fájlt/pipe-ot");
+		exit(1);
+	}
+	return file;
+}
+
+void file_close(int file) {
+	int result = close(file);
+	if (result == -1) {
+		perror("Nem sikerült bezárni a fájlt/pipe-ot");
+		exit(1);
+	}
+}
+
+void file_write(int file, void* data, size_t size) {
+	size_t result = write(file, data, size);
+	if (result == -1) {
+		perror("Hiba fájlba/pipe-ba írás során");
+		exit(1);
+	} else if (result != size) {
+		printf("Hiba fájlba/pipe-ba írás során\n");
+		exit(1);
+	}
+}
+
+void file_read(int file, void* data, size_t size) {
+	size_t result = read(file, data, size);
+	if (result == -1) {
+		perror("Hiba fájlból/pipe-ból olvasás során");
+		exit(1);
+	} else if (result != size) {
+		printf("Hiba fájlból/pipe-ból olvasás során\n");
+		exit(1);
+	}
+}
+
+FILE* text_open(char* path, char* mode) {
+	FILE* file = fopen(path, mode);
+	if (file == NULL) {
+		perror("Nem sikerült megnyitni a szöveges fájlt");
+		exit(1);
+	}
+	return file;
+}
+
+void text_close(FILE* file) {
+	int result = fclose(file);
+	if (result == EOF) {
+		perror("Nem sikerült bezárni a szöveges fájlt");
+		exit(1);
+	}
+}
+
+void text_write(int fprintf_return_value) {
+	if (fprintf_return_value < 0) {
+		perror("Hiba szöveges fájlba írás során");
+		exit(1);
+	}
+}
+
+void text_read(FILE* file, char* buffer, int chars_to_read_including_newline) {
+	if (fgets(buffer, chars_to_read_including_newline, file) == NULL) {
+		perror("Hiba szöveges fájlból olvasás során");
+		exit(1);
+	}
+}
+
+typedef struct {
+	int read;
+	int write;
+} pipes_t;
+
+pipes_t pipe_create() {
+	int tmp[2];
+	if (pipe(tmp) != 0) {
+		perror("Nem sikerült elkészíteni a csövet");
+		exit(1);
+	}
+	pipes_t pipes;
+	pipes.read = tmp[0];
+	pipes.write = tmp[1];
+	return pipes;
+}
+
+pid_t child_fork() {
+	pid_t pid = fork();
+	if (pid == -1) {
+		perror("Nem sikerült a fork");
+		exit(1);
+	}
+	return pid;
+}
+
+void child_wait_for_termination() {
+	if (wait(NULL) == -1) {
+		perror("Hiba a gyerek terminálására való várakozás során");
+		exit(1);
+	}
+}
+
+void random_init() {
+	srand(getpid() ^ time(NULL));
+}
+
+int random_get(int minInclusive, int maxExclusive) {
+	return (rand() % (maxExclusive - minInclusive)) + minInclusive;
+}
+
+typedef struct {
+	int value; //TODO
+} message_payload_t;
+
+typedef struct {
+	long type;
+	message_payload_t payload;
+} message_t;
+
+int message_create(key_t key) {
+	int queue = msgget(key, IPC_CREAT | 0666);
+	if (queue == -1) {
+		perror("Hiba üzenetsor létrehozása során");
+		exit(1);
+	}
+	return queue;
+}
+
+int message_connect(key_t key) {
+	int queue = msgget(key, 0);
+	if (queue == -1) {
+		perror("Hiba üzenetsorhoz csatlakozás során");
+		exit(1);
+	}
+	return queue;
+}
+
+void message_delete(int queue) {
+	if (msgctl(queue, IPC_RMID, NULL) != 0) {
+		perror("Hiba üzenetsor törlése során");
+		exit(1);
+	}
+}
+
+void message_send(int queue, int type, message_payload_t payload) {
+	if (type <= 0) {
+		printf("Érvénytelen üzenet típus: %d\n", type);
+		exit(1);
+	}
+	
+	message_t message;
+	message.type = type;
+	message.payload = payload;
+	if (msgsnd(queue, &message, sizeof(message.payload), 0) != 0) {
+		perror("Hiba üzenetsorba küldés során");
+		exit(1);
+	}
+}
+
+message_t message_receive(int queue, int type) {
+	message_t message;
+	ssize_t res = msgrcv(queue, &message, sizeof(message.payload), type, 0);
+	if (res == -1) {
+		perror("Hiba üzenetsorból beolvasás során");
+		exit(1);
+	} else if (res != sizeof(message.payload)) {
+		printf("Hiba üzenetsorból beolvasás során\n");
+		exit(1);
+	}
+	return message;
+}
+
+int memory_create(key_t key, size_t size) {
+	int memory = shmget(key, size, IPC_CREAT | 0666);
+	if (memory == -1) {
+		perror("Hiba osztott memória létrehozása során");
+		exit(1);
+	}
+	return memory;
+}
+
+int memory_connect(key_t key, size_t size) {
+	int memory = shmget(key, size, 0);
+	if (memory == -1) {
+		perror("Hiba osztott memória csatlakozás során");
+		exit(1);
+	}
+	return memory;
+}
+
+void memory_delete(int memory) {
+	if (shmctl(memory, IPC_RMID, NULL) != 0) {
+		perror("Hiba osztott memória törlése során");
+		exit(1);
+	}
+}
+
+void* memory_attach(int memory) {
+	void* address = shmat(memory, NULL, 0);
+	if (address == (void*) -1) {
+		perror("Hiba osztott memória cím lekérdezés során");
+		exit(1);
+	}
+	return address;
+}
+
+void memory_detach(const void* address) { //Nem történik semmi baj, ha nem csinálom meg
+	if (shmdt(address) != 0) {
+		perror("Hiba osztott memóriáról leválás során");
+		exit(1);
+	}
+}
+
+int semaphore_create(key_t key, int initial_value) {
+	int semaphores = semget(key, 1, IPC_CREAT | 0666);
+	if (semaphores == -1) {
+		perror("Hiba szemafor készlet létrehozása során");
+		exit(1);
+	}
+	if (semctl(semaphores, 0, SETVAL, initial_value) != 0) {
+		perror("Hiba szemafor készlet inicializálása során");
+		exit(1);
+	}
+	return semaphores;
+}
+
+int semaphore_connect(key_t key) {
+	int semaphores = semget(key, 1, 0);
+	if (semaphores == -1) {
+		perror("Hiba szemafor készlethez csatlakozás során");
+		exit(1);
+	}
+	return semaphores;
+}
+
+void semaphore_delete(int semaphores) {
+	if (semctl(semaphores, 0, IPC_RMID) != 0) {
+		perror("Hiba szemafor készlet törlése során");
+		exit(1);
+	}
+}
+
+void semaphore_change(int semaphores, short delta) {
+	struct sembuf operations[1];
+	operations[0].sem_num = 0;
+	operations[0].sem_flg = 0;
+	operations[0].sem_op = delta;
+	if (semop(semaphores, operations, 1) != 0) {
+		perror("Hiba szemafor változtatása során");
+		exit(1);
+	}
+}
+
+char* datetime_date() {
+	static char buffer[50];
+	time_t current = time(NULL);
+	struct tm* local = localtime(&current);
+	buffer[0] = '\0';
+	sprintf(buffer, "%d-%d-%d", local->tm_year + 1900, local->tm_mon + 1, local->tm_mday);
+	return buffer;
+}
+
+char* datetime_time() {
+	static char buffer[50];
+	time_t current = time(NULL);
+	struct tm* local = localtime(&current);
+	buffer[0] = '\0';
+	sprintf(buffer, "%d:%d:%d", local->tm_hour, local->tm_min, local->tm_sec);
+	return buffer;
+}
+
+char* datetime_date_and_time() {
+	static char buffer[100];
+	time_t current = time(NULL);
+	struct tm* local = localtime(&current);
+	buffer[0] = '\0';
+	sprintf(buffer, "%d-%d-%d %d:%d:%d",
+			local->tm_year + 1900, local->tm_mon + 1, local->tm_mday,
+			local->tm_hour, local->tm_min, local->tm_sec);
+	return buffer;
+}
+
+//TODO esetleg: timer, fájl zárolás, pollolás
+
+//////////////////////////////
+// END OF UTILITY FUNCTIONS //
+//////////////////////////////
+
+
+
+int main(int argc, char** argv) { //A -lrt kapcsoló használata szükséges fordításkor
+	return 0;
+}
diff --git a/progelm/README.md b/progelm/README.md
new file mode 100644
index 0000000..72a7cbd
--- /dev/null
+++ b/progelm/README.md
@@ -0,0 +1,11 @@
+**Képzés:** ELTE IK Proginf BSc, Szoftvertervező (B) szakirány (kezdés éve: 2020)  
+**Tárgy neve:** Programozáselmélet  
+**Tárgy kódja:** IP-18bPREE/G
+
+Létezik külön előadás és gyakorlat jegyzet, de tartalmilag nagyon hasonlók.
+A gyakorlat jegyzet készült később, ez a szebbik, pontosabb jegyzet, ami ZH-kra felkészüléshez elegendő.
+Az előadás jegyzet néhol csúnyábban formázott, viszont több információ található benne, így a vizsgára készüléshez hasznosabb.
+
+Linkek:
+ - [Gyakorlat jegyzet link](gyakorlat/progelm-gyak.pdf)
+ - [Előadás jegyzet link](előadás/progelm-ea.pdf)
diff --git "a/progelm/el\305\221ad\303\241s/progelm-ea.pdf" "b/progelm/el\305\221ad\303\241s/progelm-ea.pdf"
new file mode 100644
index 0000000..521b34a
Binary files /dev/null and "b/progelm/el\305\221ad\303\241s/progelm-ea.pdf" differ
diff --git "a/progelm/el\305\221ad\303\241s/progelm-ea.tex" "b/progelm/el\305\221ad\303\241s/progelm-ea.tex"
new file mode 100644
index 0000000..4f64a6d
--- /dev/null
+++ "b/progelm/el\305\221ad\303\241s/progelm-ea.tex"
@@ -0,0 +1,740 @@
+% !TeX spellcheck = hu_HU
+\documentclass[12pt,a4paper]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{cmap}
+\usepackage[T1]{fontenc}
+\usepackage[magyar]{babel}
+\usepackage{amsmath}
+\usepackage{amsfonts}
+\usepackage{amssymb}
+\usepackage{graphicx}
+
+\usepackage{struktex}
+\usepackage{outlines}
+\usepackage{hyperref}
+
+\hyphenpenalty=10000
+
+\begin{document}
+
+\begin{center}
+	\huge
+	Programozáselmélet\\
+	\vspace{1mm}
+	\LARGE
+	Előadás jegyzet\\
+	\vspace{5mm}
+	\large
+	Készült Borsi Zsolt előadásai\\
+	és Gregorics Tibor gyakorlatai alapján\\
+	\vspace{5mm}
+	Sárközi Gergő, 2021-22-1. félév\\
+	Nincsen lektorálva!
+\end{center}
+
+\tableofcontents
+
+\pagebreak
+
+\section{Bevezetés}
+
+\paragraph{Intervallum} $ [a..b] ::= \{ x \in \mathbb{Z} | a \le x \wedge x \le b \}$ \\
+Üres, ha $a > b$.
+
+\paragraph{Reláció, rendezett pár} $ A \times B ::= \{ (a,b) | a \in A \wedge b \in B \} $ \\
+Az $A \times B$ halmaz minden részhalmazát, az üres halmazt is, relációnak nevezzük. \\
+$ | A \times B | = |A| * |B| $ \\
+A rendezett pár felfogható relációként is: $A$-ról $B$-re képezés. \\
+Jelölése: $R \subseteq A \times B$ \\
+Legyen $A={1,2,3}$, $B={a,b,c,d}$ és $R={(1,a), (1,b), (2,c)}$. \\
+Ekkor $R \subseteq A \times B$, valamint $D_R = \{1,2\}$, és $R(1)=\{a,b\}$. \\
+$R(x) = \emptyset \Leftrightarrow |R(x)|=0 \Leftrightarrow x \notin D_R $ \\
+$D_R ::= \{ a \in A | \exists b \in B: (a,b) \in R \}$ \\
+$R_R ::= \{ b \in B | \exists a \in A: (a,b) \in R \}$ \\
+$R(a) ::= \{ b \in B | (a,b) \in R \} $ \\
+Reláció inverze: \\
+$R^{-1} = \{(b,a) \in B \times A | (a,b) \in R\}$
+
+\paragraph{Függvény, determinisztikus reláció} -\\
+Legyen $A$ és $B$ nemüres halmaz.
+$R \subseteq A \times B$ függvény, ha $\forall a \in A: |R(a)| \le 1$. \\
+Függvény jelölése: $R \in A \to B$ (ekkor $|R(a)| \le 1$) \\
+vagy $R: A \to B$ (ekkor $|R(a)| = 1$, azaz $D_R=A$) \\
+$R: A \to B$ esetén sokszor $R(a)=\{b\}$ helyett csak $R(a)=b$-t használunk
+
+\paragraph{Kompozíció} $P \subseteq A \times B$ és $Q \subseteq B \times C$\\
+Normál: \\
+$Q \circ P=\{(a,c) \in A \times C \;|\; \exists b \in B: (a,b) \in P \wedge (b,c) \in Q\}$\\
+Szigorú: ($\exists (a,b) \in P: \exists c \in C: (b,c) \not \in Q \implies (Q \odot P)(a) = \emptyset$)\\
+$Q \odot P=\{(a,c) \in A \times C \;|\; \exists b \in B: (a,b) \in P \wedge (b,c) \in Q \wedge P(a) \subseteq D_Q\}$
+
+\paragraph{Sorozatok} $H^{**} = H^* \cup H^\infty $ \\
+$H = \{1,2,3\}$ \\
+$<1,5,3> \notin H^*$, mert $5 \notin H$ \\
+$<1,1,3> \in H^*$ \\
+$<1,1,1,1,...> \notin H^*$, viszont $\in H^\infty$ \\
+
+\paragraph{Egyéb} -\\
+hamis mindent implikál: (HAMIS $\implies$ bármi) = IGAZ
+
+\pagebreak
+
+\section{Alapfogalmak}
+
+\subsection{Állapottér}
+
+\begin{outline}
+	\1 Állapot: változókkal címkézett értékek halmaza
+		\2 példa: $a=\{ v_1:a_1, v_2:a_2 \}$
+		\2 változó használata: $n(\{n:6\})=6$ (valójában $\{6\}$, de elnézzük)
+	\1 Érték: típusérték-halmaz egy eleme
+	\1 Állapottér: összes lehetséges állapot halmaza
+		\2 jelölés: $A=( v_1:A_1, v_2:A_2 )$
+	\1 Az $A$ állapottérnek altere a $B$ állapottér ($B<A$),
+	ha a $B$ állapottér típusértékei (számmosságot is figyelmbe véve) benne vannak $A$-ban is.
+		\2 példa: $A=(x:\mathbb{N},y:\mathbb{N},z:\mathbb{N})$
+		és $B=(y:\mathbb{N},x:\mathbb{N})$ akkor $B<A$.
+		\2 A típusérték-halmazoknak meg kell egyezniük: az nem "elég",
+		ha az egyik a másiknak csak a  részhalmaza. \\
+		Itt egyik sem részhalmaza a másiknak: $A=(x:\mathbb{N)}$, $B=(x:\mathbb{Z})$
+		\2 TODO lehet különböző a változó neve?
+\end{outline}
+
+\subsection{Feladat}
+
+\begin{outline}
+	\1 Feladat: reláció, amely egy állapottérről ugyan arra az állapottérre képez
+		\2 Ha $A$ állapottér, akkor $F \subseteq A \times A$ egy feladat.
+		\2 Tehát $F=\{\}$ is egy feladat.
+\end{outline}
+
+\subsubsection{Példa}
+
+Adjuk meg egy pozitív egész szám egy pozitív osztóját. \\
+$A=( n:\mathbb{N}^+, d:\mathbb{N}^+ )$ \\
+$D_F = A$ \\
+$F \subseteq A \times A$ \\
+$F(\{n:6,d:11\}) = \{ \{n:6,d:2\}, \{n:6,d:3\}, ... \} $ \\
+Itt a kimenetnél nézőpont kérdése, hogy n=6 feltétel-e, vagy meg lehetne változtatni. \\
+$F(x,y)=\{(u,v) ; u=x \wedge v|x\}$ \\
+$F(x,*)=\{(*,v) ; v|x\}$ \\
+$F = \{(u,v) \in A \times A \;|\; d(v)|n(u) \}$
+
+\pagebreak
+
+\subsection{Program}
+
+\begin{outline}
+	\1 Leképezés, amely megadja bármelyik kiinduló állapotra az abból induló végrehajtási sorozatokat.
+	\1 Program: $S \subseteq A \times (\overline{A} \cup \{fail\})^{**}$ ahol:
+		\2 $\overline{A} = \underset{A \le B}{\bigcup} B $
+		\2 $D_S=A$ (minden bemenetet lekezel)
+		\2 $\forall a \in A: \forall vs \in S(a): |vs| \ge 1 \wedge vs_1 = a$
+		(végrehajtási sorozat nem üres és első tagja a bemenet)
+		\2 $\forall vs \in R_S: (\forall i \in \mathbb{N}^+: i < |vs| \to vs_i \neq fail)$
+		(csak az utolsó állapot lehet fail)
+		\2 $\forall vs \in R_S: |vs|<\infty \to vs_{|vs|} \in A \cup \{fail\}$
+		(az utolsó állapot, ha van ilyen, csak alap-állapottérbeli vagy fail lehet)
+\end{outline}
+
+\subsubsection{Alap-állapottér}
+
+\begin{outline}
+	\1 nincsenek benne a segédváltozók
+	\1 kiindulási állapot mindig alap-állapottérbeli
+	\1 végállapot alap-állapottérbeli, vagy fail
+\end{outline}
+
+\subsubsection{Végrehajtási sorozat}
+
+\begin{outline}
+	\1 első tagja mindig a bemeneti állapot
+	\1 ha van benne fail, akkor csak leghátul lehet
+	\1 segédváltozók a végrehajtási sorozat első és utolsó tagjában nincsenek, viszont a többiben igen
+	\1 legalább 1, max. végtelen hosszú
+	\1 egy kezdő állapotból több különböző végrehajtási sorozat indulhat
+	\1 értékadás, ami nem változtat semmit is generál új végrehajtási sorozatot
+\end{outline}
+
+\subsubsection{Példa}
+
+$A=(x:\{1,2,3\})$ \\
+S program (azaz halmaz) elemei: (mindegyik felírás helyes)\\
+$\{x:1\} \to <\{x:1\}, \{x:3\}>$ \\
+$1 \to <1,1,1>$ \\
+$(2) \to <(2), (3), (4)>$ \\
+$(3, <3, fail>)$
+
+\subsection{Programfüggvény}
+
+\begin{outline}
+	\1 megadja egy program lehetséges végállapotait (amik sem fail, sem végtelenek nem lehetnek) egy adott kezdőállapot esetén
+	\1 Programfüggvény: egy reláció, pl. $p(S) \subseteq A \times A$
+		\2 ez a $S \subseteq A \times (\overline{A} \cup \{fail\})^{**}$ programhoz van
+		\2 $D_{p(S)} = \{ a \in A | S(a) \subseteq \overline{A}^* \}$
+		(ott értelmes, ahol S csak véges, csak nem fail végrehajtási sorozatot ad)
+		\2 $\forall a \in D_{p(S)}: p(S)(a) = \{b \in A | \exists vs \in S(a): b=vs_{|vs|}\}$
+		(azaz $p(S)(x)$ = 'S program lehetséges végállapotjai (halmaza) $x$ kezdőállapot esetén')
+		\2 ha $x \notin D_{p(S)}$, akkor $p(S)(x) = \emptyset$
+\end{outline}
+
+\subsection{Megoldás}
+
+\begin{outline}
+	\1 S program megoldja az F feladatot (S program teljesen helyes F feladatra nézve) ha:
+		\2 $D_F \subseteq D_{p(S)}$ (feladat minden kezdőállapotát le tudja kezelni)
+		\2 $\forall a \in D_F : p(S)(a) \subseteq F(a)$
+		(program végállapotja, bármilyen feladatban értelmezett kezdőállapot esetén,
+		részhalmaza a feladat "megoldáshalmazának")
+\end{outline}
+
+\pagebreak
+
+\subsection{Parciális helyesség}
+
+\begin{outline}
+	\1 Nem hasznos, nem nagyon fogjuk használni.
+	\1 Gyenge programfüggvény:
+		\2 $\widetilde{p}(S) \subseteq A \times (A \cup \{fail\})$ reláció
+		\2 $S \subseteq A \times (\overline{A} \cup \{fail\})^{**}$ programhoz való
+		\2 $D_{\widetilde{p}(S)} = \{ a \in A | S(a) \cap (\overline{A} \cup \{fail\})^* \ne \emptyset \}$
+		(ott értelmes, ahol S ad véges végállapotot is)
+			\3 fail-t megenged, de végtelent nem
+			\3 értelmezve van, ha azonos bemenethez van végtelen és véges megoldás is
+		\2 $\forall a \in D_{\widetilde{p}(S)}: \widetilde{p}(S)(a) =$\\
+		$\{b \in A \cup \{fail\} | \exists vs \in S(a) \cap (\overline{A} \cup \{fail\})^*: b=vs_{|vs|}\}$ \\
+		(azaz $\widetilde{p}(S)(x)$ = 'S program lehetséges végállapotjai (halmaza) $x$ kezdőállapot esetén, csak véges vs-eket nézve')
+	\1 Parciális helyesség ($S$ program parciálisan helyes az $F$ feladatra nézve):
+		\2 ha $\forall a \in D_F: \widetilde{p}(S)(a) \subseteq F(a)$
+		\2 szóval végtelen vs-ek kivételével: mint a rendes megoldás
+\end{outline}
+
+\subsection{Elemi programok}
+
+\begin{outline}
+	\1 Elemi program definíció: $\forall a \in A: S(a) \subseteq$ \\
+	$\{ <a>, <a,fail>, <a,a,a,...>, <a,b> | b \in A \}$
+	\1 Nevezetes elemi programok:
+		\2 $\forall a \in A: ABORT(a) = \{<a, fail>\}$
+		\2 $\forall a \in A: SKIP(a) = \{<a>\}$
+		\2 értékadás (x := 1)
+		\2 szimultán értékadás (x,y := y,x)
+		\2 értékkiválasztás (x :$\in$ \{n-1, n-2\})
+\end{outline}
+
+\pagebreak
+
+\subsection{Programok, programfüggvények, stb. relációi}
+
+\subsubsection{$S_1 \subseteq S_2 \implies D_{p(S_2)} \subseteq D_{p(S_1)}$}
+
+Bizonyítás: \\
+$a \in D_{p(S_i)} \Leftrightarrow S_i(a) \subseteq \overline{A}^*$ (def) \\
+$S_1 \subseteq S_2 \implies S_1(a) \subseteq S_2(a)$ \\
+$(S_2(a) \subseteq \overline{A}^*) \wedge (S_1(a) \subseteq S_2(a))
+\implies (S_1(a) \subseteq (S_2(a) \subseteq \overline{A}^*)$
+
+\subsubsection{$S_1 \subseteq S_2 \implies \forall a \in D_{p(S_2)}: p(S_1)(a) \subseteq p(S_2)(a)$}
+
+Bizonyítás: \\
+$x \in p(S_i)(a) \Leftrightarrow \exists vs \in S_i(a): vs_{|vs|}=x$ (def) \\
+$S_1 \subseteq S_2 \implies S_1(a) \subseteq S_2(a)$ \\
+$(\exists vs \in S_1(a): vs_{|vs|}=x) \wedge (S_1(a) \subseteq S_2(a))
+\implies (\exists vs \in S_2(a): vs_{|vs|}=x)$
+
+\subsubsection{$S' \subseteq S$ és S megoldja F-et, akkor S' is}
+
+Lásd előző kettő bizonyítás: \\
+$D_F \subseteq D_{p(S)} \subseteq D_{p(S')}$ \\
+$p(S')(a) \subseteq p(S)(a) \subseteq F(a)$
+
+\subsubsection{$F \subseteq F'$ és S megoldja F'-t, attól még S nem oldja meg F-t}
+
+Példa: F' nem determinisztikus, F kevesebb megoldást fogad el.
+
+\subsubsection{Determinisztikusság relációk}
+
+F, S és p(S) determinisztikussága nagyrészt (vagy egyáltalán?) nem következtethető ki egymásból.
+
+\subsubsection{Szigorúbb feladat}
+
+\begin{outline}
+	\1 $F_2 \subseteq A \times A$ feladat szigorúbb, mint $F_1 \subseteq A \times A$, ha:
+		\2 $D_{F_1} \subseteq D_{F_2}$ \;\;(több helyen értelmezett)
+		\2 $\forall a \in D_{F_1}: F_2(a) \subseteq F_1(a)$ \;\;(kevesebb jó kimenet)
+		\2 Tehát egy feladat önmagának is a szigorítása
+	\1 Állítás: ha $S$ program megoldja $F_2$-t, akkor $F_1$-et is
+	\1 Bizonyítás: $D_{F_1} \subseteq D_{F_2} \subseteq D_{p(S)}$\\
+	és $\forall a \in D_{F_1}: p(S)(a) \subseteq F_2(a) \subseteq F_1(a)$
+\end{outline}
+
+\pagebreak
+
+\section{Logikai függvények}
+
+\begin{outline}
+	\1 Legyen $R \in A \to \mathbb{L}$,
+	ekkor $\lceil R \rceil = \{ a \in A | R(a) = {igaz} \}$
+	\1 Igazsághalmaz: $\lceil R \rceil$
+	\1 $D_R$ nem feltétlenül $A$ ($\in$ jelölés miatt), tehát attól még, hogy nem igaz valahol, nem feltétlenül hamis ott. Éppen ezért egy ilyen logikai függvényt nem lehet megadni csak az igazságtáblájával.
+		\2 Viszont megegyezés miatt igazságtáblával megadott logikai függvény mindenhol értelmezve van.
+	\1 $R : A \to \mathbb{L}$ viszont már a teljes $A$-n értelmezve van
+	\1 Nevezetes logika függvények:
+		\2 $\forall a \in A: IGAZ(a) = \{igaz\}$ \\
+		$\lceil IGAZ \rceil = A$
+		\2 $\forall a \in A: HAMIS(a) = \{hamis\}$ \\
+		$\lceil HAMIS \rceil = \emptyset$
+	\1 Példa: $A=(x:\mathbb{N})$, $R=(1<x<3)$
+\end{outline}
+
+\subsection{Műveletek logika függvényekkel}
+
+\begin{outline}
+	\1 Legyen $A$ felett $Q,R$ logikai függvények
+	\1 $Q \wedge R = \{ a \in A | Q(a) \wedge R(a) \}$
+	\1 $Q \lor R = \{ a \in A | Q(a) \lor R(a) \}$
+\end{outline}
+
+\subsection{Következik reláció, maga után vonás}
+
+\begin{outline}
+	\1 $Q,R \in A \to \mathbb{L}$ és $A \ne \emptyset$
+	\1 $(Q \implies R) \Leftrightarrow (\lceil Q \rceil \subseteq \lceil R \rceil)$
+		\2 ha Q(x) igaz, akkor R(x) is
+	\1 Vegyünk tetszőleges $P \in A \to \mathbb{L}$ függvényt
+		\2 $P \implies IGAZ$
+		\2 $HAMIS \implies P$
+\end{outline}
+
+\pagebreak
+
+\section{Leggyengébb előfeltétel}
+
+\begin{outline}
+	\1 Logikai függvény, amely pontosan ott igaz, ahonnan kiindulva $S$ hibátlanul terminál
+	és az összes lehetséges végállapotban $R$ igaz.
+	\1 Legyen $S \subseteq A \times (\overline{A} \cup \{fail\})^{**}$ program
+	és $R \in A \to \mathbb{L}$ logika függvény
+	\1 $lf(S,R) : A \to \mathbb{L}$
+		\2 tehát minden A-beli ponthoz (pontosan egy) logikai értéket rendel
+	\1 $\lceil lf(S,R) \rceil = \{ a \in A | a \in D_{p(S)}
+	\wedge p(S)(a) \subseteq \lceil R \rceil \}$
+	\1 Leggyengébb, mert $P \implies lf(S,R)$ esetén $P$ szigorúbb, mint $lf(S,R)$
+\end{outline}
+
+\subsection{lf tulajdonságai}
+
+\begin{outline}
+	\1 Legyen $A$ felett $S$ egy program és $Q,R$ logikai függvények
+	\1 Általános tulajdonságok:
+		\2 $lf(S,HAMIS) = HAMIS$
+		\2 ha $Q \implies R$, akkor $lf(S,Q) \implies lf(S,R)$
+		\2 $lf(S,Q) \wedge lf(S,R) = lf(S,Q \wedge R)$
+		\2 $lf(S,Q) \lor lf(S,R) \implies lf(S,Q \lor R)$
+		\2 $\lceil lf(S,IGAZ) \rceil = D_{p(S)}$
+	\1 Elemi függvényekkel:
+		\2 $\lceil lf(ABORT,R) \rceil = \emptyset$
+		\2 $lf(ABORT,R) = HAMIS$
+		\2 $\lceil lf(SKIP,R) \rceil = \lceil R \rceil$
+		\2 $lf(SKIP,R) = R$
+\end{outline}
+
+\subsection{lf kiszámolása}
+
+\begin{outline}
+	\1 $\lceil lf(S,R) \rceil = \{a \in A \;|\; a \in D_{p(S)}$ és behelyettesítjük R-be S-t $\}$
+	\1 pl.: $\lceil lf((x:=x+1),(x<10)) \rceil=\{a \in A \;|\; igaz \wedge (x<10)^{\leftarrow x:=x+1}\}=\{a \in A \;|\; x'=x(a)+1 \wedge x' < 10\}=\{a \in A \;|\; x(a)+1 < 10\} = (x<9)$
+\end{outline}
+
+\pagebreak
+
+\section{Paramétertér, specifikáció tétele}
+
+\subsection{Paramétertér}
+
+\begin{outline}
+	\1 $B$ az $F \subseteq A \times A$ feladat paramétertere, ha
+		\2 létezik $F_1 \subseteq A \times B$ és $F_2 \subseteq B \times A$
+		\2 hogy $F = F_2 \circ F_1$
+	\1 Minden feladatnak létezik paramétertere:\\
+	legyen $B=A$, $F_1 = id$ és $F_2 = F$
+	\1 Minden feladatnak végtelen sok paramétertere van
+	\1 paraméter: paramétertér egy eleme
+\end{outline}
+
+\subsection{Specifikáció tétele}
+
+\begin{outline}
+	\1 Legyen:
+		\2 $S \subseteq A \times (\overline{A} \cup \{fail\})^{**}$ egy program
+		\2 $F \subseteq A \times A$ egy feladat
+		\2 $B$ az $F$ egy paramétertere
+			\3 $F_1 \subseteq A \times B$ és $F_2 \subseteq B \times A$
+			\3 $F = F_2 \circ F_1$
+	\1 Definiáljunk kettő $A \to \mathbb{L}$ logikai fv-t minden paraméterhez ($\forall b \in B$)
+		\2 $\lceil Q_b \rceil = F_1^{-1}(b)$ (olyan $a$-k, amikhez $F_1$ rendel egy $b$-t)
+		\2 $\lceil R_b \rceil = F_2(b)$ (olyan $a$-k, amiket $F_2$ rendel egy $b$-hez)
+	\1 Ekkor: $(\forall b \in B: Q_b \implies lf(S,R_b)) \implies$ ($S$ megoldja $F$-et)
+	\1 Szóval ez egy elégséges, de nem szükséges feltétel
+	\1 Előfeltétel gyengítésével és/vagy utófeltétel szigorításával egy \textit{szigorúbb feladat}ot kapunk.
+\end{outline}
+
+\pagebreak
+
+\subsubsection{Bizonyítás: $(\forall b \in B: Q_b \implies lf(S,R_b)) \implies$ ($S$ mo. $F$-et)}
+
+\begin{outline}
+	\1 $D_F \subseteq D_{p(S)}$
+		\2 $a \in D_F \implies \exists b \in B: (a,b) \in F_1 \implies a \in \lceil Q_b \rceil$
+		\2 $\lceil lf(S,R_b) \rceil = \{a \in D_{p(S)} | p(S)(a) \subseteq \lceil R_b \rceil\} \subseteq D_{p(S)}$
+		\2 $(Q_b \implies lf(S,R_b)) \implies \lceil Q_b \rceil \subseteq \lceil lf(S,R_b) \rceil \subseteq D_{p(S)}$
+		\2 beláttuk, hogy $a \in D_F \implies a \in \lceil Q_b \rceil \subseteq D_{p(S)}$
+	\1 $\forall a \in D_F: p(S)(a) \subseteq F(a)$
+		\2 $\lceil lf(S,R_b) \rceil = \{a \in D_{p(S)} | p(S)(a) \subseteq \lceil R_b \rceil\}$
+			\3 tehát $p(S)(a) \subseteq \lceil R_b \rceil$
+		\2 $F_2(b) \subseteq F(a)$
+		\2 beláttuk, hogy $p(S)(a) \subseteq \lceil R_b \rceil = F_2(b) \subseteq F(a)$
+\end{outline}
+
+\subsection{Feladat specifikációja}
+
+$F(n,*) = \{(n,d) \;|\; d|n\}$\\
+$A=(n:\mathbb{N}^+, d:\mathbb{N}^+)$ (állapottér)\\
+$B=(n':\mathbb{N}^+)$ (paramétertér)\\
+$\forall b \in B: Q_b(a) = (n(a) = n'(b))$\\
+$\forall b \in B: R_b(a) = (n(a) = n'(b) \wedge d(a)|n(a))$\\
+Rövidebben:\\
+$Q=(n=n')$ (előfeltétel)\\
+$R=(Q \wedge d|n)$ (utófeltétel)
+
+\subsection{Példa}
+
+Adott egy egész szám. Növeljük meg 1-gyel!\\
+$A=(x:\mathbb{Z})$\\
+$B=(x':\mathbb{Z})$\\
+$Q=(x=x')$\\
+$R=(x=x'+1)$\\
+Helyesség belátása:\\
+$S=(x:=x+1)$, tehát ezt kell belátni: $Q \implies lf(x:=x+1, R)$\\
+R-ben helyettesítés: $Q \implies (x+1=x'+1)$\\
+Azaz: $(x=x') \implies (x+1=x'+1)$
+
+\pagebreak
+
+\section{Új jelölések}
+
+\begin{outline}
+	\1 Ha egy $l: \mathbb{L}$ igaz, akkor \textit{valami}: $l \to valami$
+	\1 Intervallum: $\forall i \in [1..n]: ...$
+	\1 Függvény: $f : \mathbb{Z} \to \mathbb{Z}$
+	\1 Tömb: $x:\mathbb{Z}^n$, ahol $n \in \mathbb{N}$ (n-t nem kell külön bevezetni)
+		\2 1-től indexelünk, meghozzá így: $x[1]$
+\end{outline}
+
+\section{Programkonstrukciók}
+
+\subsection{Szekvencia}
+
+\begin{outline}
+	\1 Legyen $S_1$ és $S_2$ program $A$ állapottéren
+	\1 $(S_1;S_2)$ reláció a két program szekvenciája
+	\1 $(S_1;S_2)(a) =$\\
+	$\{vs \in \overline{A}^\infty \;|\; vs \in S_1(a)\}$ \;\;\;($S_1$ végtelen vs-t ad)\\
+	$\cup \{vs \in (\overline{A} \cup \{fail\})^* \;|\; vs \in S_1(a) \wedge vs_{|vs|}=fail\}$ \;\;\;($S_1$ vs vége fail)\\
+	$\cup \{vs \in (\overline{A} \cup \{fail\})^{**} \;|\; vs=x \oplus y \wedge x \in S_1(a) \wedge |x| < \infty \wedge x_{|x|} \ne fail \wedge y \in S_2(x_{|x|}) \}$
+	\;\;\;($S_1$ vs véges és nem fail, ekkor $S_2$-vel folytatjuk)
+	\1 Nem adom meg a szekvencia állapotterét, csak a két programot: több lehetséges alap állapottér van, mert lehetnek segédváltozók.
+	\1 TODO ezeket ellenőrizni (hivatalos jegyzetben nincsenek benne)
+		\2 $p((S_1;S_2))=p(S_2) \odot p(S_1)$
+		\2 $D_{p((S_1;S_2))}=\{a \in D_{p(S_1)} \;|\; p(S_1)(a) \subseteq D_{p(S_2)} \}$
+\end{outline}
+
+\subsubsection{Szekvencia mint megoldó program}
+
+\begin{outline}
+	\1 $S_1$ megoldja $F_1$-t, $S_2$ megoldja $F_2$-t, $S$ legyen $(S_1;S_2)$
+	\1 $S$ nem oldja meg $F_2 \circ F_1$-t ($F_1$ legyen tágabb, stb... bonyolult)
+	\1 $S$ megoldja $F_2 \odot F_1$-t (hosszú a bizonyítás, gyakon nem is volt MÉG)
+\end{outline}
+
+\pagebreak
+
+\subsection{Elágazás}
+
+\begin{outline}
+	\1 Legyen $S_1,S_2,...,S_n$ programok, $\pi_1,\pi_2,...,\pi_n$ logikai függvények A felett
+		\2 azaz $\pi_i \in A \to L$, nem pedig $\pi_i : A \to L$
+	\1 $IF=IF(\pi_1:S_1,...,\pi_n:S_n)$
+		\2 $\forall a \in A: IF(a) = w_0(a) \cup \bigcup_{i=1..n}w_i(a)$
+		\2 $w_0(a)=\begin{cases}
+		\{<a,fail>\} \text{\;ha\;} \forall i \in [i..n]: (a \in D_{\pi_i} \wedge \lnot \pi_i(a))\\
+		\emptyset \text{\;különben}
+		\end{cases}$
+		\2 $w_i(a) = \begin{cases}
+		S_i(a) \text{\;ha\;} a \in D_{\pi_i} \wedge \pi_i(a)\\
+		\emptyset \;\;\;\;\; \text{\;ha\;} a \in D_{\pi_i} \wedge \lnot \pi_i(a)\\
+		\{<a,fail>\} \text{\;ha\;} a \not\in D_{\pi_i}\\
+		\end{cases}$
+	\1 Megjegyzések
+		\2 több $\pi_i$ egyszerre teljesül: mindet belerakjuk a halmazba
+		\2 $\pi_i$ valahova nem rendel semmit: fail-t is rendelünk oda (de a vs első eleme a valami)
+		(Emlékeztető: igazsághalmazzal megadott logikai fv megegyezés szerint mindenhova rendel valamit.)
+		\2 összes $\pi_i$ egyszerre hamis: fail-t rendelünk oda (de a vs első eleme a valami)
+\end{outline}
+
+\subsubsection{Programfüggvény}
+
+\begin{outline}
+	\1 $D_{p(IF)}=\{a\in A \;|\; a \in \bigcap D_{\pi_i} \wedge a \in \bigcup\lceil \pi_i \rceil \wedge (a \in \lceil \pi_i \rceil \implies a \in D_{p(S_i)} )\}$
+	\1 $p(IF)(a)=\bigcup_{i=1..n}\{ x \in p(S_i)(a) \; | \; a \in \lceil \pi_i \rceil\ \}$
+\end{outline}
+
+\pagebreak
+
+\subsection{Ciklus}
+
+\begin{outline}
+	\1 Legyen $S$ program, $\pi$ logikai függvény $A$ felett
+	\1 $DO(\pi:S)$ az elöl tesztelő ciklus ($S$ ciklusmag, $\pi$ ciklusfeltétel)
+		\2 $DO(a)=\begin{cases}
+			(S;DO)(a) \text{\;ha\;} a \in D_\pi \wedge \pi(a)\\
+			<a> \;\;\;\;\;\;\; \text{\;ha\;} a \in D_\pi \wedge \lnot \pi(a)\\
+			<a,fail> \text{\;ha\;} a \not \in D_\pi
+			\end{cases}$
+		\2 végtelen ciklus jelölése:
+			\3 $DO(\pi:S)=\{1 \to <1,1,1...>\}$
+			\3 $DO(\pi:S)=\{1 \to <1,(2,3,1)^{\infty}...>\}$
+			\3 $DO(\pi:S)=\{1 \to <1,(2,3,1)^*,4>\}$ (*: véges sokszor)
+	\1 Programfüggvények:
+		\2 TODO $p(DO)$ és $D_{p(DO)}$ =?
+		\2 $D_{p(S)} \not \subseteq D_{p(DO)}$ (mert: IGAZ és SKIP)
+		\2 $D_{p(DO)} \not \subseteq D_{p(S)}$ (mert: HAMIS és ABORT)
+\end{outline}
+
+\pagebreak
+
+\section{Levezetési szabályok}
+
+\subsection{Szekvencia levezetési szabálya}
+
+\begin{outline}
+	\1 Legyen $S=(S_1;S_2)$ program és $Q,Q',R$ logikai függvény
+	\1 Ha $Q \implies lf(S_1,Q')$ és $Q' \implies lf(S_2,R)$
+	\1 Akkor (és csak akkor) $Q \implies lf(S,R)$
+	\1 Magyarázat: $Q \implies lf(S,R)$ jelentése: $S$ elvisz $Q$-ból $R$-be
+		\2 Szóval: $Q \to (S_1) \to Q' \to (S_2) \to R$
+\end{outline}
+
+\subsection{Elágazás levezetési szabálya}
+
+\begin{outline}
+	\1 Legyen $IF=IF(\pi_1:S_1,...,\pi_n:S_n)$ és $Q,R$ logikai függvény 
+	\1 Ha
+		\2 $Q \implies AND_{i=1}^{n} \pi_i \lor \lnot \pi_i$ \;\; (mindegyik mindenhol értelmes)
+		\2 $Q \implies OR_{i=1}^{n} \pi_i$ \;\; (mindenhol legalább egy teljesül)
+		\2 $\forall i \in [1..n]: Q \wedge \pi_i \implies lf(S_i,R)$ \;\; (bármelyik ágon $R$ igaz lesz)
+	\1 Akkor $Q \implies lf(IF,R)$
+\end{outline}
+
+\subsection{Ciklus levezetési szabálya}
+
+\begin{outline}
+	\1 Legyen $DO=DO(\pi:S)$ és $P,Q,R$ logikai függvény, ahol $P$ invariáns\\
+	és $t:A \to \mathbb{Z}$ termináló állítás
+	\1 Ha
+		\2 $Q \implies P$ \;\; (invariáns alapból teljesül)
+		\2 $P \wedge \lnot \pi \implies R$ \;\; (jó helyen áll meg)
+		\2 $P \implies \pi \lor \lnot \pi$ \;\; (ciklusfeltétel nem abortál)
+		\2 $P \wedge \pi \implies t > 0$ \;\; (cikluson belül van még lépés)
+		\2 $P \wedge \pi \wedge t = t_0 \implies lf(S,P \wedge t<t_0)$ \;\; (invariáns marad, lépés\;-\;-)
+	\1 Akkor $Q \implies lf(DO,R)$
+	\1 $P$ az invariáns állítás, $t$ a terminálófüggvény (hány lépés van hátra)
+\end{outline}
+
+\pagebreak
+
+\section{Helyességbizonyítás}
+
+\subsection{Módszere}
+
+\begin{outline}
+	\1 Be akarjuk látni, hogy $S$ megoldja az $A,B,Q,R$ specifikációjú feladatot.
+	\1 1. lépés: ST (Specifikáció Tétele) miatt elég belátni: $Q \implies lf(S,R)$
+	\1 2. lépés: fenti állítás belátása, $S$-től függően:
+		\2 értékadás/kiválasztás: közvetlenül belátható ($R$-be behelyettesítés)
+		\2 szekvencia: SZLSZ (Szekvencia Levezetési Szabálya) használata
+		\2 elágazás: ELSZ (Elágazás Levezetési Szabálya) használata
+		\2 ciklus: CLSZ (Ciklusz Levezetési Szabálya) használata
+	\1 A 2. lépésben rekurzívan ismételjük a 2. lépést, amíg be nem látunk minden állítást.
+\end{outline}
+
+\subsection{Megvalósítási tippek}
+
+\begin{outline}
+	\1 Belátok valamit, ami nem definícióból következik (pl. $1<2$): PIPA
+	\1 Értékkiválasztás: $lf(x:\in h, x \; even) = (h \ne \emptyset \wedge \forall e \in h : e \; even)$
+	\1 $Q \implies ...$ esetén vegyem úgy, hogy $Q$ igaz és lássam be $...$-ot
+	\1 ($\forall k \in [1..n]: x[k]=...$)-on ($x[i]=...$) végrehajtása: $\forall k$ 3 részre bontása: ($\forall k \in [1..i-1]: ...$) és ($x[i]=...$) és ($\forall k \in [i+1..n]: ...$)
+	\1 $\lor$ (vagy)-ból következés: esetszétválasztás, akár negált is felhasználható, pl.: ($a \lor b \implies ...$)-nél: ($a \implies$) vagy ($\lnot a \wedge b \implies$)
+	\1 Értékadások és számolások, amik abortálhatnak:
+		\2 $a := b$ ahol $a : A$ és $b : B$ abortál, ha $B \not \subseteq A$
+		\2 $a \mod b$ abortál, ha $b=0$
+		\2 $x[i]$ ahol $x:\mathbb{Z}^n$ abortál, ha $i \notin [1..n]$
+\end{outline}
+
+\section{Pszeudokód jelölések}
+
+\begin{outline}
+	\1 Ciklus: $while \; VALAMI \; do \; [...] \; od$
+\end{outline}
+
+\pagebreak
+
+\section{Párhuzamos programok}
+
+\begin{outline}
+	\1 Értékadás és feltétel kiértékelés nem megszakítható (atomikus)
+\end{outline}
+
+\subsection{Annotációk (pl. $\{Q_7\}$)}
+
+\begin{outline}
+	\1 Egy program egy adott pontjához egy logikai függvény: elő/utófeltétel.
+	\1 Segédváltozókat is felvehetünk ennek érdekében. Ezzel a program megváltozik, de a helyessége nem: a segédváltozók nem módosítjak a nem-segédeket.
+\end{outline}
+
+\subsection{Atomi program}
+
+\begin{outline}
+	\1 $[S](a) = S(a)$
+	\1 Atomikus: nem megszakítható
+	\1 $S$ nem tartalmazhat sem ciklust, sem várakoztató utasítást (?)
+	\1 Levezetési szabály:
+		\2 Ha $Q \implies lf(S,R)$
+		\2 Akkor $Q \implies lf([S],R)$
+\end{outline}
+
+\subsection{Várakoztató utasítás}
+
+\begin{outline}
+	\1 $\beta \in A \to \mathbb{L}$ (őrfeltétel)
+	\1 Stukis jelölés: szekvencia, ahol a felső rész felet boltív van ($\cap$)
+	\1 $(await \; \beta \; then \; S \; ta)(a) = $
+		\2 ha $a \in D_\beta \wedge \beta(a)$ akkor $[S](a)$ \;\; ($\beta$ és $S$ együtt atomikus)
+		\2 ha $a \in D_\beta \wedge \lnot \beta(a)$ akkor $(skip,await \; \beta \; then \; S \; ta)(a)$
+		\2 ha $a \notin D_\beta$ akkor $<a,fail>$
+	\1 Levezetési szabály
+		\2 Ha
+			\3 $Q \implies \beta \lor \lnot \beta$ \;\; ($\beta$ kiértékelhető)
+			\3 $Q \wedge \beta \implies lf(S,R)$
+		\2 Akkor $Q \implies lf(await \; \beta \; then \; S \; ta,R)$
+	\1 $S$ nem tartalmazhat sem ciklust, sem várakoztató utasítást (?)
+\end{outline}
+
+\pagebreak
+
+\subsection{Párhuzamos blokk}
+
+\begin{outline}
+	\1 $S_i$: komponens programok
+		\2 vagy $S_i$ atomikus (nem megszakítható)
+		\2 vagy $S_i=(u_i,T_i)$ ahol $u_i$ az első utasítás, $T_i$ a többi
+	\1 Stukis jelölés: $x:=x+2 \; || \; x := 0$
+	\1 $(parbegin \; S_1||...||S_n \; parend)(a)=\bigcup_{i=1}^n B_i(a)$
+	\1 $B_i(a) = $
+		\2 ha $S_i$ atomikus: $(S_i;parbegin \; S_1||...||S_{i-1}||S_{i+1}||...||S_n \; parend)(a)$
+		\2 ha $S_i=(u_i,T_i)$: $(u_i;parbegin \; S_1||...||S_{i-1}||T_i||S_{i+1}||...||S_n \; parend)(a)$
+	\1 Holtpontra jutott, ha minden be nem fejeződött komponense
+		\2 vagy egy várakoztató utasítás, aminek őrfeltétele hamis (azaz blokkolt)
+		\2 vagy egy szekvencia, amelyben van blokkolt várakoztató utasítás
+	\1 Levezetési szabály: (PLSZ)
+		\2 Legyenek $Q_i$ és $R_i$ ($i=[1..n]$) logikai függvények (annotációk)
+		\2 Ha
+			\3 $Q \implies Q_1 \wedge ... \wedge Q_n$ \;\; (belépési feltétel)
+			\3 $R_1 \wedge ... \wedge R_n \implies R$ \;\; (jó helyen állunk meg)
+			\3 $\forall i \in [1..n] : Q_i \implies lf(S_i,R_i)$
+			\3 $Q_i \implies lf(S_i,R_i)$ teljes helyességi interferencia formulák interferenciamentesek
+			\3 párhuzamos blokk holtpontmentes
+		\2 Akkor $Q \implies lf(parbegin \; S_1||...||S_n \; parend, R)$
+\end{outline}
+
+\subsection{Kritikus utasítás}
+
+\begin{outline}
+	\1 Vagy egy értékadás
+	\1 Vagy egy atomikusan végrehajtott program, ami tartalmaz értékadást
+		\2 A várakoztató utasítás atomikus!!!
+\end{outline}
+
+\pagebreak
+
+\subsection{Interferenciamentesség}
+
+\begin{outline}
+	\1 Legyen $u$ egy $pre_u$ előfeltételű kritikus utasítás $S_i$-ben
+	\1 Legyen $s$ egy tetszőleges, $pre_s$ előfeltételű utasítás $S_j$-ben ($S_j$ tetszőleges)
+	\1 $u$ nem interferál a $Q_j \implies lf(S_j,R_j)$ teljes helyességi formulával ha:
+		\2 $pre_u \wedge R_j \implies lf(u,R_j)$ \;\; ($u$ végrehajtása nem rontja el $R_j$-t)
+		\2 $pre_u \wedge pre_s \implies lf(u,pre_s)$ \;\; ($u$ végrehajtása nem rontja el $pre_s$-t)
+		\2 $pre_u \wedge t=t_0 \implies lf(u, t \le t_0)$\\
+		ahol $t$ egy tetszőleges $S_j$-beli ciklus terminálófüggvénye \\
+		($u$ végrehajtása miatt nem "számol" visszafelé ciklus)
+	\1 Gyakorlatban:
+		\2 $Q_1 = (x=0)$; $Q_2=igaz$
+		\2 $R_1=R_2 = (x=0) \lor (x=2)$
+		\2 be kell látni: $1 \leadsto 2: \{Q_1\}x := x+2 \leadsto Q_2,R_2$
+			\3 első rész: $R_2 \wedge Q_1 \implies lf(x:=x+2, R_2)$
+			\3 második rész: $Q_2 \wedge Q_1 \implies lf(x := x+2, Q_2)$
+		\2 be kell látni: $2 \leadsto 1: \{Q_2\}x := 0 \leadsto Q_1,R_1$
+			\3 Ha 1 ciklus lenne: $\{Q_2\}x := 0 \leadsto Q_1,R_1,P$ és fenti $t$-s
+			\3 Ha nincs közös változó: "nincs krit. ut. az 1. ágra nézve"
+		\2 Alternatíva: "elég" belátni: a kritikus utasítás egy annotációt sem ront el,
+		valamint a ciklus terminálófüggvény sem számol felfelé.
+		\2 Emlékeztető: hamis bármit implikál ($\implies$ előtt ellentmondás)
+\end{outline}
+
+\pagebreak
+
+\subsection{Elégséges feltétel holtpontmentességre}
+
+\begin{outline}
+	\1 Legyen $m$ $await$ és $n$ párhuzamos blokk egy $S$ szekvenciában
+		\2 $A_m: await \; \beta_m \; then \; S_m \; ta$
+		\2 $T_n : parbegin \; S^n_1||...||S^n_{n_n} \; parend$
+	\1 $D(S)=[\bigvee_{j=1}^{m} (pre(A_j) \wedge \lnot \beta_j)] \lor [\bigvee_{k=1}^{n}D1(T_k)]$
+		\2 vagy egy $await$ miatt várok
+		\2 vagy egy párhuzamos blokk van holtpontban
+	\1 $D1(T_k) = [\bigwedge_{j=1}^{n_k} (post(S_i^k) \lor D(S_i^k))] \wedge [\bigvee_{i=1}^{n_k}D(S_i^k)]$
+		\2 az összes komponens már befejezedőtött vagy holtpontban van
+		\2 és legalább egy komponens holtpontban van
+	\1 Ha $D(S)=HAMIS$, akkor biztosan nincs holtpont. Egyébként nem mondunk semmit.
+\end{outline}
+
+\subsubsection{Holtpontmentesség: egy await egy kétágú párhuzamos blokkban}
+
+\begin{outline}
+	\1 Legyen $S=parbegin \; (await \; \beta \; then \; S_1 \; ta) \; ||\; S_2 \; parend$
+	\1 Bizonyítás nélkül használható tény: csak akkor van ekkor holtpont ha\\
+	$pre(await \; \beta \; then \; S_1 \; ta) \wedge \lnot \beta \wedge post(S_2)$
+	\1 Ha ez ellentmondást ad ($=hamis$), akkor nincs holtpont
+\end{outline}
+
+\subsubsection{Holtpontmentesség: két await egy kétágú párhuzamos blokkban}
+
+\begin{outline}
+	\1 Legyen $S=parbegin \; (await \; \beta_1 \; then \; S_1 \; ta) \; ||\; (await \; \beta_2 \; then \; S_2 \; ta) \; parend$
+		\2 Átfogalamzva: $S=parbegin \; A_1||A_2 \; parend$
+	\1 Bizonyítás nélkül használható tény: csak akkor van ekkor holtpont ha
+		\2 vagy: $pre(A_1) \wedge \lnot \beta_1 \wedge post(A_2)$
+		\2 vagy: $pre(A_2) \wedge \lnot \beta_2 \wedge post(A_1)$
+		\2 vagy: $pre(A_1) \wedge \lnot \beta_1 \wedge pre(A_2) \wedge \lnot \beta_2$
+	\1 Ha ez ellentmondást ad ($=hamis$), akkor nincs holtpont
+\end{outline}
+
+\subsubsection{Holtpontmentesség: nincs await}
+
+\begin{outline}
+	\1 Mindig holtpontmentes.
+\end{outline}
+
+\end{document}
diff --git a/progelm/gyakorlat/progelm-gyak.pdf b/progelm/gyakorlat/progelm-gyak.pdf
new file mode 100644
index 0000000..77f82e9
Binary files /dev/null and b/progelm/gyakorlat/progelm-gyak.pdf differ
diff --git a/progelm/gyakorlat/progelm-gyak.tex b/progelm/gyakorlat/progelm-gyak.tex
new file mode 100644
index 0000000..225a590
--- /dev/null
+++ b/progelm/gyakorlat/progelm-gyak.tex
@@ -0,0 +1,298 @@
+% !TeX spellcheck = hu_HU
+\documentclass[12pt,a4paper]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{cmap}
+\usepackage[T1]{fontenc}
+\usepackage[magyar]{babel}
+\usepackage{amsmath}
+\usepackage{amsfonts}
+\usepackage{amssymb}
+\usepackage{graphicx}
+
+\usepackage{struktex}
+\usepackage{outlines}
+\usepackage{hyperref}
+
+\hyphenpenalty=10000
+
+\begin{document}
+
+\begin{center}
+	\huge
+	Programozáselmélet\\
+	\vspace{1mm}
+	\LARGE
+	Összefoglaló / gyakorlat jegyzet\\
+	\vspace{5mm}
+	\large
+	Készült Borsi Zsolt előadásai\\
+	és Gregorics Tibor gyakorlatai alapján\\
+	\vspace{5mm}
+	Sárközi Gergő, 2021-22-1. félév\\
+	Nincsen lektorálva!
+\end{center}
+
+\tableofcontents
+
+\pagebreak
+
+\section{ZH 1 összefoglaló}
+
+\subsection{Jelölések, matematikai alapok}
+
+\begin{outline}
+	\1 Jelölni "ha $l : \mathbb{L}$ igaz, akkor $abc$" így: $l \to abc$
+	\1 Tömb: $x : \mathbb{Z}^n$ ahol $n \in \mathbb{N}$ (nem kell külön bevezetni); első elem: $x[1]$
+	\1 Intervallum: $i: [1..n]$ vagy $\forall j \in [1..n]$
+	\1 Reláció: $R \subseteq A \times B$ (üres halmaz is az)
+	\1 Függvény: $R \in A \to B$ ($|R(a)|\le1$); vagy $R : A \to B$ ($D_R=A$)
+	\1 Kompozíció: $Q \circ P=\{(a,c) \in A \times C \;|\; \exists b \in B: (a,b) \in P \wedge (b,c) \in Q\}$
+	\1 Sorozatok: $H^{**} = H^* \cup H^\infty$ (véges/végtelen hossz); \; pl.: <1,2,2,...>
+		\2 $*$ véges sokat, akár nullát jelöl. Példa: $<0,1,(2,3)^*,(4,5)^\infty>$
+	\1 $\lceil R \rceil = \{a \in A | R(a) = igaz\}$ és $(Q \implies R) \Leftrightarrow (\lceil Q \rceil \subseteq \lceil R \rceil)$
+		\2 $R \in A \to \mathbb{L}$ akkor $\lceil R \rceil$ csak megegyezés miatt adhatja meg $D_R$-t
+\end{outline}
+
+\subsection{Programok, programfüggvények, stb. relációi}
+
+\begin{outline}
+	\1 Ezek mind levezethetők definíciókból.
+	\1 $S_1 \subseteq S_2 \implies D_{p(S_2)} \subseteq D_{p(S_1)}$
+	\1 $S_1 \subseteq S_2 \implies \forall a \in D_{p(S_2)}: p(S_1)(a) \subseteq p(S_2)(a)$
+	\1 $S' \subseteq S$ és $S$ megoldja $F$-et, akkor $S'$ is
+	\1 $F \subseteq F'$ és $S$ megoldja $F'$-t, attól még $S$ nem oldja meg $F$-t
+	\1 $F$, $S$ és $p(S)$ determinisztikussága nem nagyon következtethető ki egymásból.
+\end{outline}
+
+\subsection{lf tulajdonságai}
+
+\begin{outline}
+	\1 ha $Q \implies R$ akkor $lf(S,Q) \implies lf(S,R)$
+	\1 $lf(S,Q) \wedge lf(S,R) = lf(S,Q \wedge R)$ ($\lor$-val is igaz)
+	\1 Számolás: $R$-be behelyettesítjük $S$-t: (és $S$ nem abortál)\\
+	$lf((x:=3),(x<10))=(igaz \wedge (x<10)^{\leftarrow x := 3})=(3 < 10)=igaz$
+\end{outline}
+
+\pagebreak
+
+\subsection{Alapfogalmak}
+
+\begin{outline}
+	\1 Állapot: változókkal címkézett értékek; állapottér: lehetséges állapotok
+		\2 Alap-állapottér: segédváltozók nélküli (azaz $A$, nem pedig $\overline{A}$)
+	\1 Feladat: $F \subseteq A \times A$ ahol $A$ egy állapottér
+	\1 Program: $S \subseteq A \times (\overline{A} \cup \{fail\})^{**}$ ahol:
+		\2 $D_S=A$ és a végrehajtási sorozat (vs) első tagja a bemenet
+		\2 Az utolsó állapot lehet csak $fail$; valamint vagy $fail$ vagy $A$-beli
+		\2 Semmit nem változtató értékadás is bekerül a végrehajtási sorozatba.
+	\1 Programfüggvény: $p(S) \subseteq A \times A$ ahol $S$ program $A$ felett
+		\2 $D_{p(S)}=\{a \in A|S(a) \subseteq \overline{A}^* \}$ (ahol $S$ véges, nem $fail$ vs-t ad)
+		\2 $p(S)(a) = \{b \in A | \exists vs \in S(a): b=vs_{|vs|}\}$ (utolsó vs tagok)
+	\1 Megoldás: $S$ m.o. $F$-et ha $D_F \subseteq D_{p(S)}$ és $\forall a \in D_F : p(S)(a) \subseteq F(a)$
+	\1 Gyenge programfüggvény: $\tilde{p}(S) \subseteq A \times (A \cup \{fail\})$
+		\2 $D_{\tilde{p}(S)}= \{ a \in A | S(a) \cap (\overline{A} \cup \{fail\})^* \ne \emptyset \}$ \;\; (ahol min 1 véges vs)
+		\2 $\widetilde{p}(S)(a) = \{b \in A \cup \{fail\} | \exists vs \in S(a) \cap (\overline{A} \cup \{fail\})^*: b=vs_{|vs|}\}$
+	\1 Parciális helyesség: $S$ parc. helyes $F$-re ha $\forall a \in D_F: \widetilde{p}(S)(a) \subseteq F(a)$
+	\1 Leggyengébb előfeltétel: $lf(S,R) : A \to \mathbb{L}$ \;\; (ahonnan $S$ után $R$ igaz)
+		\2 $\lceil lf(S,R) \rceil = \{a \in A | a \in D_{p(S)} \wedge p(S)(a) \subseteq \lceil R \rceil \}$
+\end{outline}
+
+\subsection{Paramétertér, specifikáció}
+
+\begin{outline}
+	\1 $B$ az $F$ paramétertere ha $F=F_2 \circ F_1$ (ahol $F_1 \subseteq A \times B$ és $F_2 \subseteq B \times A$)
+		\2 minden feladatnak végtelen sok van, pl.: $B=A$, $F_1 = i$d, $F_2 = F$
+		\2 paraméter: paramétertér egy eleme (hasonló: állapottér vs állapot)
+	\1 Specifikáció: $A$ (állapottér), $B$ (paramtér), $Q$ (előfeltétel), $R$ (utófeltétel)
+		\2 $\forall b \in B: \lceil Q_b \rceil = F_1^{-1}(b)$ ($a$-k, amikhez $F_1$ rendel $b$-t)
+		\2 $\forall b \in B: \lceil R_b \rceil = F_2(b)$ ($a$-k, amiket $F_2$ rendel egy $b$-hez)
+		\2 ha $\forall b \in B: Q_b \implies lf(S,R_b)$ akkor $S$ megoldja $F$-t
+	\1 Szigorúbb feladat: gyengített előfeltétel és/vagy szigorúbb utófeltétel.
+\end{outline}
+
+\pagebreak
+
+\section{ZH 2 összefoglaló}
+
+\subsection{Programkonstrukciók}
+
+\subsubsection{Szekvencia: $(S_1;S_2)$}
+
+\begin{outline}
+	\1 $(S_1;S_2)(a) =$\\
+	$\{vs \in \overline{A}^\infty \;|\; vs \in S_1(a)\}$ \;\;\;($S_1$ végtelen vs-t ad)\\
+	$\cup \{vs \in (\overline{A} \cup \{fail\})^* \;|\; vs \in S_1(a) \wedge vs_{|vs|}=fail\}$ \;\;\;($S_1$ vs vége fail)\\
+	$\cup \{vs \in (\overline{A} \cup \{fail\})^{**} \;|\; vs=x \oplus y \wedge x \in S_1(a) \wedge |x| < \infty \wedge \\ x_{|x|} \ne fail \wedge y \in S_2(x_{|x|}) \}$
+	\;\;\;($S_1$ vs véges és nem fail: $S_2$-vel folytatjuk)
+	\1 $p((S_1;S_2))=p(S_2) \odot p(S_1)$ \;\; (szigorú kompozíció)\\
+	$Q \odot P=\{(a,c) \in A \times C \;|\; \exists b \in B: (a,b) \in P \wedge (b,c) \in Q \wedge P(a) \subseteq D_Q\}$
+	\1 $D_{p((S_1;S_2))}=\{a \in D_{p(S_1)} \;|\; p(S_1)(a) \subseteq D_{p(S_2)} \}$
+\end{outline}
+
+\subsubsection{Elágazás: $IF=IF(\pi_1:S_1,...,\pi_n:S_n)$}
+
+\begin{outline}
+	\1 $IF(a) = w_0(a) \cup \bigcup_{i=1..n}w_i(a)$
+		\2 $w_0(a)=<a,fail>$ ha $\forall i: (a \in D_{\pi_i} \wedge \lnot \pi_i(a))$
+		egyébként $\emptyset$
+		\2 $w_i(a) = \begin{cases}
+		S_i(a) \text{\;ha\;} a \in D_{\pi_i} \wedge \pi_i(a)\\
+		\emptyset \;\;\;\;\; \text{\;ha\;} a \in D_{\pi_i} \wedge \lnot \pi_i(a)\\
+		\{<a,fail>\} \text{\;ha\;} a \not\in D_{\pi_i}\\
+		\end{cases}$
+	\1 $p(IF)(a)=\bigcup_{i=1..n}\{ x \in p(S_i)(a) \; | \; a \in \lceil \pi_i \rceil\ \}$
+	\1 $D_{p(IF)}=\{a\in A \;|\; a \in \bigcap D_{\pi_i} \wedge a \in \bigcup\lceil \pi_i \rceil \wedge (a \in \lceil \pi_i \rceil \implies a \in D_{p(S_i)} )\}$
+\end{outline}
+
+\subsubsection{Ciklus: $DO=DO(\pi:S)$}
+
+\begin{outline}
+	\1 $DO(a)=\begin{cases}
+	(S;DO)(a) \text{\;ha\;} a \in D_\pi \wedge \pi(a)\\
+	<a> \;\;\;\;\;\;\; \text{\;ha\;} a \in D_\pi \wedge \lnot \pi(a)\\
+	<a,fail> \text{\;ha\;} a \not \in D_\pi
+	\end{cases}$
+	\1 $p(DO)(a) = ?$ \;\; (nem hangzott el EA-n)
+	\1 $D_{p(DO)} = \lceil \lnot \pi \rceil \cup \{ x \in \lceil \pi \rceil \cap D_{p(S)}
+	\; | \; p(S)(x) \subseteq D_{p(DO)} \}$ (nem volt EA-n)
+\end{outline}
+
+\pagebreak
+
+\subsubsection{Atomi program: $[S](a)=S(a)$}
+
+\begin{outline}
+	\1 Atomikus: nem megszakítható
+		\2 Értékadások, logikai függvények kiértékelése alapból atomikus
+	\1 $S$ nem tartalmazhat sem ciklust, sem várakoztató utasítást (Miért?)
+	\1 $p([S])=p(S)$ és $D_{p([S])}=D_{p(S)}$
+\end{outline}
+
+\subsubsection{Várakoztató utasítás: $await \; \beta \; then \; S \; ta$; stukiban: $\frac{{\cap \atop \beta}}{S}$}
+
+\begin{outline}
+	\1 $S$ nem tartalmazhat sem ciklust, sem várakoztató utasítást (Miért?)
+	\1 $(await \; \beta \; then \; S \; ta)(a) = \begin{cases}
+		[S](a) \text{\;ha\;} a \in D_\beta \wedge \beta(a) \;\; \text{($\beta$ és $S$ együtt atomikus)}\\
+		(skip,await \; \beta \; then \; S \; ta)(a) \text{\;ha\;} a \in D_\beta \wedge \lnot \beta(a)\\
+		<a,fail> \text{\;ha\;} a \not \in D_\beta
+		\end{cases}$
+	\1 $p(AWAIT)=p(S)$ \;\; (nem hangzott el EA-n)
+	\1 $D_{p(AWAIT)}=\lceil \lnot \beta \rceil \cup (\lceil \beta \rceil \cap D_{p(S)})$ \;\; (nem hangzott el EA-n)
+	\1 Holtpontban van, ha nem egy párhuzamos blokk része és $Q \implies \lnot \beta$
+\end{outline}
+
+\subsubsection{Párhuzamos blokk: $parbegin \; S_1||...||S_n \; parend$; stukiban: $S_1 || S_2$}
+
+\begin{outline}
+	\1 $(parbegin \; S_1||...||S_n \; parend)(a)=\bigcup_{i=1}^n (u_i;parbegin \; ...||S_{i-1}||T_i||S_{i+1}||... \; parend)(a)$
+		\2 ahol $S_i=(u_i,T_i)$ \;\; ($T_i$ nincs, ha $S_i$ atomikus)
+	\1 $p(PAR) = ?$ \;\; (nem hangzott el EA-n)
+	\1 $D_{p(PAR)} = ?$ \;\; (nem hangzott el EA-n)
+	\1 Holtpontra jutott, ha minden (és legalább 1) be nem fejeződött komponense ($S_i$) tartalmaz hamis őrfeltételű várakoztató utasítást (blokkolt).
+	\1 Interferencia: értékadások "megtámadhatják" a komponensek helyességét.
+		\2 Formálisan: kritikus utasítások támadhatnak, amik vagy értékadások, vagy atomikus programok, bennük értékadással.
+\end{outline}
+
+\pagebreak
+
+\subsection{Levezetési szabályok}
+
+\subsubsection{Specifikáció Tétele}
+
+\begin{outline}
+	\1 Legyen $F$ feladat specifikációja $A,B,Q,R$
+	\1 Ha $Q \implies lf(S,R)$ akkor $S$ program megoldja $F$-et
+\end{outline}
+
+\subsubsection{SZekvencia Levezetési SZabálya}
+
+\begin{outline}
+	\1 Legyen $S=(S_1;S_2)$; elő- és utófeltételek: $Q \to (S_1) \to Q' \to (S_2) \to R$
+	\1 Ha $Q \implies lf(S_1,Q')$ és $Q' \implies lf(S_2,R)$ akkor $Q \implies lf(S,R)$
+\end{outline}
+
+\subsubsection{Elágazás Levezetési SZabálya}
+
+\begin{outline}
+	\1 Legyen $IF=IF(\pi_1:S_1,...,\pi_n:S_n)$
+	\1 Ha az alsók teljesülnek, akkor $Q \implies lf(S,R)$
+		\2 $Q \implies AND_{i=1}^{n} \pi_i \lor \lnot \pi_i$ \;\; (mindegyik mindenhol értelmes)
+		\2 $Q \implies OR_{i=1}^{n} \pi_i$ \;\;\;\;\;\;\;\;\;\;\;\;\;\; (mindenhol legalább egy teljesül)
+		\2 $\forall i \in [1..n]: Q \wedge \pi_i \implies lf(S_i,R)$ \;\; (bármelyik ágon $R$ igaz lesz)
+\end{outline}
+
+\subsubsection{Ciklus Levezetési SZabálya}
+
+\begin{outline}
+	\1 Legyen $DO=DO(\pi:S)$, $P$ invariáns és $t$ termináló függvény
+	\1 Ha az alsók teljesülnek, akkor $Q \implies lf(DO, R)$
+		\2 $Q \implies P$ \;\; (invariáns alapból teljesül)
+		\2 $P \wedge \lnot \pi \implies R$ \;\; (jó helyen áll meg)
+		\2 $P \implies \pi \lor \lnot \pi$ \;\; (ciklusfeltétel nem abortál)
+		\2 $P \wedge \pi \implies t > 0$ \;\; (cikluson belül van még lépés)
+		\2 $P \wedge \pi \wedge t = t_0 \implies lf(S,P \wedge t<t_0)$ \;\; (invariáns marad, lépés\;-\;-)
+\end{outline}
+
+\subsubsection{Atomi program Levezetési SZabálya}
+
+\begin{outline}
+	\1 Ha $Q \implies lf(S,R)$ akkor $Q \implies lf([S],R)$
+\end{outline}
+
+\pagebreak
+
+\subsubsection{Várakoztató utasítás Levezetési SZabálya}
+
+\begin{outline}
+	\1 Ha az alsók teljesülnek, akkor $Q \implies lf(await \; \beta \; then \; S \; ta, R)$
+		\2 $Q \implies \beta \lor \lnot \beta$ \;\; (őrfeltétel nem abortál)
+		\2 $Q \wedge \beta \implies lf(S,R)$
+	\1 Holtpontban van, ha nem egy párhuzamos blokk része és $Q \implies \lnot \beta$
+\end{outline}
+
+\subsubsection{Párhuzamos blokk Levezetési SZabálya}
+
+\begin{outline}
+	\1 Ha az alsók teljesülnek, akkor $Q \implies lf(parbegin \; S_1||...||S_n \; parend, R)$
+		\2 $Q \implies Q_1 \wedge ... \wedge Q_n$ \;\; (belépési feltétel)
+		\2 $R_1 \wedge ... \wedge R_n \implies R$ \;\; (jó helyen állunk meg)
+		\2 $\forall i \in [1..n] : Q_i \implies lf(S_i,R_i)$
+		\2 $Q_i \implies lf(S_i,R_i)$ teljes helyességi interferencia formulák interferenciamentesek
+		\2 párhuzamos blokk holtpontmentes
+	\1 Interferenciamentesség: $u$ nem interferál $Q \implies lf(S,R)$-rel, ha:
+		\2 $pre_u \wedge Q \implies lf(u,Q)$
+		\2 $pre_u \wedge R \implies lf(u,R)$
+		\2 Ha $S$-ben van ciklus: $pre_u \wedge t=t_0 \implies lf(u,t \le t_0)$
+		\2 Ezt be kell látnia az összes $u$ értékadásra és az összes, $u$-tól különböző komponensben található $Q \implies lf(S,R)$ helyességi formulára.
+		\2 Egyszerűsítési lehetőség: $u$ nem változtat a $Q \implies lf(S,R)$ által használt változókon. ("1 $\leadsto$ 2: nincs krit. ut.")
+		\2 Hamis bármit implikál: $\implies$ előtt ellentmondás az egyből jó
+	\1 Holtpontmentesség: nem lehet holtpontban (mert pl. nincs várakoztatás)
+		\2 Be kell látni, hogy hamis: minden komponens vagy kész van, vagy blokkolt és legalább egy komponens blokkolt.
+		\2 Példa: $parbegin \; (await \; \beta \; then \; S_1 \; ta) \; || \; S_2 \; parend$
+			\3 Be kell látni, hogy hamis: $pre(AWAIT) \wedge \lnot \beta \wedge post(S_2)$
+		\2 Példa: $parbegin \; await \; \beta_1 \; then \; S_1 \; ta \; || \; await \; \beta_2 \; then \; S_2 \; ta \; parend$
+			\3 Be kell látni, hogy ezek mindegyike hamis:
+			\3 $pre(A_1) \wedge \lnot \beta_1 \wedge post(A_2)$
+			\3 $pre(A_2) \wedge \lnot \beta_2 \wedge post(A_1)$
+			\3 $pre(A_1) \wedge \lnot \beta_1 \wedge pre(A_2) \wedge \lnot \beta_2$
+\end{outline}
+
+\pagebreak
+
+\subsection{Helyességbizonyítás}
+
+\begin{outline}
+	\1 Menete: specifikáció tételének felhasználása, majd mindent, ami nem értékadás, az ő levezetési szabályával levezetünk.
+	\1 $Q \implies ...$ esetén vegyem úgy, hogy $Q$ igaz és lássam be $...$-ot
+	\1 Helyezzek ki pipákat, ha belátok valamit, pl. hogy $1+1 < 3$
+	\1 Értékkiválasztás: $lf(x:\in h, x \; even) = (h \ne \emptyset \wedge \forall e \in h : e \; even)$
+	\1 ($\forall k \in [1..n]: x[k]=...$)-on ($x[i]=...$) végrehajtása: $\forall k$ 3 részre bontása: ($\forall k \in [1..i-1]: ...$) és ($x[i]=...$) és ($\forall k \in [i+1..n]: ...$)
+	\1 $\lor$ (vagy)-ból következés: esetszétválasztás, akár negált is felhasználható, pl.: ($a \lor b \implies ...$)-nél: ($a \implies$) vagy ($\lnot a \wedge b \implies$)
+	\1 Értékadások és számolások, amik abortálhatnak:
+		\2 $a := b$ ahol $a : A$ és $b : B$ abortál, ha $B \not \subseteq A$
+		\2 $a \mod b$ abortál, ha $b=0$
+		\2 $x[i]$ ahol $x:\mathbb{Z}^n$ abortál, ha $i \notin [1..n]$	
+\end{outline}
+
+\end{document}
diff --git "a/valsz\303\241m-stat/README.md" "b/valsz\303\241m-stat/README.md"
new file mode 100644
index 0000000..dd775ed
--- /dev/null
+++ "b/valsz\303\241m-stat/README.md"
@@ -0,0 +1,9 @@
+**Képzés:** ELTE IK Proginf BSc, Szoftvertervező (B) szakirány (kezdés éve: 2020)  
+**Tárgy neve:** Valószínűségszámítás és statisztika  
+**Tárgy kódja:** IP-18bVSZEG
+
+A jegyzet témakörönként külön-külön fájlra van bontva.
+
+Linkek:
+ - [Valószínűségszámítás jegyzet link](valószínűségszámítás/valszámstat-valószínűségszámítás.pdf)
+ - [Statisztika jegyzet link](statisztika/valszámstat-statisztika.pdf)
diff --git "a/valsz\303\241m-stat/statisztika/becsl\303\251sek.png" "b/valsz\303\241m-stat/statisztika/becsl\303\251sek.png"
new file mode 100644
index 0000000..85d5fcd
Binary files /dev/null and "b/valsz\303\241m-stat/statisztika/becsl\303\251sek.png" differ
diff --git "a/valsz\303\241m-stat/statisztika/boxplot.png" "b/valsz\303\241m-stat/statisztika/boxplot.png"
new file mode 100644
index 0000000..2f312e2
Binary files /dev/null and "b/valsz\303\241m-stat/statisztika/boxplot.png" differ
diff --git "a/valsz\303\241m-stat/statisztika/f\303\274ggetlens\303\251gvizsg\303\241lat.png" "b/valsz\303\241m-stat/statisztika/f\303\274ggetlens\303\251gvizsg\303\241lat.png"
new file mode 100644
index 0000000..d3470d2
Binary files /dev/null and "b/valsz\303\241m-stat/statisztika/f\303\274ggetlens\303\251gvizsg\303\241lat.png" differ
diff --git "a/valsz\303\241m-stat/statisztika/konfidenciaintervallum.png" "b/valsz\303\241m-stat/statisztika/konfidenciaintervallum.png"
new file mode 100644
index 0000000..8e87cf1
Binary files /dev/null and "b/valsz\303\241m-stat/statisztika/konfidenciaintervallum.png" differ
diff --git "a/valsz\303\241m-stat/statisztika/korrel\303\241ci\303\263.png" "b/valsz\303\241m-stat/statisztika/korrel\303\241ci\303\263.png"
new file mode 100644
index 0000000..ad800eb
Binary files /dev/null and "b/valsz\303\241m-stat/statisztika/korrel\303\241ci\303\263.png" differ
diff --git "a/valsz\303\241m-stat/statisztika/kritikus-tartom\303\241nyok.png" "b/valsz\303\241m-stat/statisztika/kritikus-tartom\303\241nyok.png"
new file mode 100644
index 0000000..719dac4
Binary files /dev/null and "b/valsz\303\241m-stat/statisztika/kritikus-tartom\303\241nyok.png" differ
diff --git "a/valsz\303\241m-stat/statisztika/param\303\251teres-pr\303\263ba-v\303\241laszt\303\241s.png" "b/valsz\303\241m-stat/statisztika/param\303\251teres-pr\303\263ba-v\303\241laszt\303\241s.png"
new file mode 100644
index 0000000..6bb4e3e
Binary files /dev/null and "b/valsz\303\241m-stat/statisztika/param\303\251teres-pr\303\263ba-v\303\241laszt\303\241s.png" differ
diff --git "a/valsz\303\241m-stat/statisztika/valsz\303\241mstat-statisztika.pdf" "b/valsz\303\241m-stat/statisztika/valsz\303\241mstat-statisztika.pdf"
new file mode 100644
index 0000000..9b6dbd4
Binary files /dev/null and "b/valsz\303\241m-stat/statisztika/valsz\303\241mstat-statisztika.pdf" differ
diff --git "a/valsz\303\241m-stat/statisztika/valsz\303\241mstat-statisztika.tex" "b/valsz\303\241m-stat/statisztika/valsz\303\241mstat-statisztika.tex"
new file mode 100644
index 0000000..a523ece
--- /dev/null
+++ "b/valsz\303\241m-stat/statisztika/valsz\303\241mstat-statisztika.tex"
@@ -0,0 +1,1086 @@
+% !TeX spellcheck = hu_HU
+\documentclass[12pt,a4paper]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{cmap}
+\usepackage[T1]{fontenc}
+\usepackage[magyar]{babel}
+\usepackage{amsmath}
+\usepackage{amsfonts}
+\usepackage{amssymb}
+\usepackage{graphicx}
+
+\usepackage{outlines}
+
+\usepackage{hyperref}
+\hypersetup{ colorlinks=true, linkcolor=blue }
+
+\hyphenpenalty=10000
+
+\begin{document}
+
+\begin{center}
+	\huge
+	Valószínűségszámítás és statisztika\\
+	\vspace{1mm}
+	\LARGE
+	Statisztika témakör jegyzet\\
+	\vspace{5mm}
+	\large
+	Készült Zempléni András előadásai\\
+	és Kovács Ágnes gyakorlatai alapján\\
+	\vspace{5mm}
+	Sárközi Gergő, 2021-22-2. félév\\
+	Nincsen lektorálva!
+\end{center}
+
+\tableofcontents
+
+\pagebreak
+
+\section{Előadás 7: Statisztika bevezetés}
+
+\begin{outline}
+	\1 Két fő ág: leíró (újságokba), matematikai (becsléselmélet, hipotizéselmélet)
+	\1 Lényeges, hogy válaszainkat értelmezzük, mondatban válaszoljunk: laikusuk is értsék meg az eredményt.
+\end{outline}
+
+\subsection{Leíró statisztika alapfogalmak}
+
+\begin{outline}
+	\1 Statisztikai egység: vizsgálat tárgyát képező egység
+	\1 Statisztikai sokaság (populáció): egységek összessége, halmaza
+		\2 Lehet hipotetikus is: gyár által jelenleg tervezett gyártandó termékek
+	\1 Statisztikai adat: sokaságra vonatkozó számszerű jellemző, mérési eredmény
+	\1 Statisztikai ismérv: sokaság egyedeit jellemző tulajdonság
+	\1 Ismérvváltozatok: ismérvek lehetséges kimenetelei
+	\1 Minta: sokaság véges számosságú részhalmaza
+	\1 Statisztikai következtetés: teljes sokaságot nem ismerjük, de a minta alapján következtetünk valamit a teljes sokaságról
+\end{outline}
+
+\subsubsection{Ismérvek típusai}
+
+\begin{outline}
+	\1 Első kategória
+		\2 Minőségi: számszerűen nem mérhető
+		\2 Mennyiségi: számszerűen mérhető, lehet diszkrét vagy folytonos
+		\2 Időbeli
+		\2 Területi
+	\1 Második kategória
+		\2 Közös: sokaság egyedei között egyformák
+		\2 Megkülönböztető: sokaság egyedei között eltérőek
+\end{outline}
+
+\pagebreak
+
+\subsubsection{Mérési skálák (mérési szintek)}
+
+\begin{outline}
+	\1 Névleges (nominális): hozzárendelt számok csak megkülönböztetnek, műveleteket végezni rajtuk értelmetlen (pl. személy neme)
+	\1 Sorrendi (ordinális): valamilyen tulajdonság alapján sorba rendezünk, egyedek tulajdonsága közötti különbséget nem tudjuk mérni (pl. érdemjegy)
+	\1 Intervallumskála: skálaértekek különbségei is valós infót adnak, a nullpont meghatározása a skálán önkényes (pl. hőmérséklet C-ben)
+	\1 Aranyskála: skálának van valódi nullpontja és minden matematikai művelet végezhető (pl. személyek magassága)
+	\1 Metrikus skála (ritkán használt): intervallum és aranyskála közös neve
+\end{outline}
+
+\subsubsection{Statisztikai tábla}
+
+\begin{outline}
+	\1 Statisztikai sorok összefüggő rendszere
+	\1 Egyszerű tábla: nincsenek csoportok, összegző sorok
+	\1 Csoportosító tábla:
+		\2 Egyetlen csoportosító szempont
+		\2 Gyakoriság van csak benne: hányan esnek a csoportba
+	\1 Kombinációs tábla, kontingenciatábla, kereszttábla:
+		\2 Legalább két csoportosító szempont
+		\2 Gyakoriságok vannak csak benne
+\end{outline}
+
+\pagebreak
+
+\subsection{Statisztikai elemzés lépései}
+
+\begin{outline}
+	\1 Tervezés: mit vizsgálunk, hogyan gyűjtünk adatot, előzetes sejtések/hipotézis
+	\1 Adatgyűjtés
+	\1 Adatbevitel
+	\1 Adatok validálása: nyilván rossz értékek kiszűrése (pl. negatív életkor)
+	\1 Adatelemezés, adatellenőrzés (leíró statisztika, grafikonok)
+	\1 Hibás adatok kijavítása vagy kihagyása
+		\2 Lehetőleg ki kell javítani, nem pedig kidobni (nehéz feladat)
+	\1 Adatelemzés, statisztikai következtetések levonása (matematikai statisztika)
+	\1 Eredmények értelmezése, visszacsatolás
+\end{outline}
+
+\subsection{Mennyiségi sorok elemzése}
+
+\begin{outline}
+	\1 Ismérv diszkrét $\implies$ gyakorisági sort készítünk
+	\1 Ismérv folytonos vagy sok van belőle: osztályközös gyakorisági sor
+		\2 Összevonunk több ismérvet: $A_i$ és $B_i$ közötti gyakoriságot számolunk
+	\1 Gyakori jelölések: $n$ a minta mérete, $k$ az ismérvértékek (sorok) száma, $f_i$ a gyakoriság és $x_i$ (vagy $x_{i,a} - x_{i,f}$ ha nem diszkrét) az ismérvérték
+		\2 Osztályközös esetén $x_i$ az osztályközepet jelöli: $x_i = \frac{x_{i,a} + x_{i,f}}{2}$
+\end{outline}
+
+\subsection{Középértékek számolása}
+
+\begin{outline}
+	\1 Mintaátlag, közvetlen adatból: $\overline{x} = \frac{\sum_{i=1}^{n} x_i}{n}$
+	\1 Mintaátlag, osztályközös gyakorisági sorokból: $\overline{x} = \frac{\sum_{i=1}^{n} f_i*x_i}{n}$
+	\1 Módusz: legtöbbször előforduló ismérvérték
+	\1 Medián: sorba rendezés után középső elem (rendezett minta: $X^*$)
+		\2 $Me = \begin{cases}
+		x^*[\frac{n+1}{2}] & \text{ ha $n$ páratlan}\\
+		\frac{1}{2}*(x^*[\frac{n}{2}] + x^*[\frac{n}{2}+1]) & \text{ ha $n$ páros}
+		\end{cases}$
+\end{outline}
+
+\pagebreak
+
+\subsection{Kvantilisek}
+
+\begin{outline}
+	\1 y-kvantilis: $q_y = \inf\{ x \;|\; F(x) \ge y \}$
+		\2 Ha $F$ invertálható: $q_y = F^{-1}(y)$
+	\1 Tapasztalati $y$-kvanatilis: ismérvérték; mintaelemek $y$-ad része $\le$ nála
+		\2 Sokféleképpen számolható, interpolációs módszer az egyik:
+		\2 Sorszám megállapítása ($e$ egészrész, $t$ törtrész): $(n+1)y=e+t$
+		\2 Kvantilis kiszámolása: $q_z = X^*_e + t(X^*_{e+1} - X^*_e)$
+	\1 Jelölje $q_y$ a tapasztalati $y$-kvantilist
+	\1 Tercilisek: $T_1 = q_{1/3}$, $T_2 = q_{2/3}$
+	\1 Kvartilisek: $Q_1 = q_{1/4}$ (alsó), $Q_2 = Me = q_{2/4}$, $Q_3 = q_{3/4}$ (felső)
+	\1 Percentilisek: $P_i = q_{i/100}$ ahol $i = 1,2,...,99$
+\end{outline}
+
+\subsection{Tapasztalati eloszlás}
+
+\begin{outline}
+	\1 Minden megfigyeléshez $\frac{1}{n}$ súlyt rendelünk $\implies$ diszkrét eloszlás
+	\1 $\overline{X} = E(X)$
+	\1 Tapasztalati eloszlásfüggvény: $F_n(x) = \frac{1}{n} * \sum_{i=1}^{n} I(x_i < x)$
+		\2 $I$ az indikátor, értéke $0$ (ha $X_i < x$) vagy $1$ (ha $X_i \ge x$)
+		\2 Ábrázolva: ahol szakadás van, azt az értéket tudja felvenni\\
+		(az ugrás mértéke a valószínűség)
+	\1 k-adik tapasztalati momentum: $m_k = \frac{1}{n} * \sum_{i=1}^n X_i^k$
+	\1 Glivenko-Cantelli tétel: tapasztalati eloszlásfüggvény ($F_n(x)$) és az elméleti eloszlásfüggvény ($F(x)$) közötti eltérés maximuma 1 valószínűséggel 0-hoz konvergál
+		\2 Következmény: $F_n(x)$ közelít $F(x)$-hez ($\forall x$ esetén) a minta növésével
+		\2 Elég nagy mintával tetszőleges közelséget el lehet érni
+\end{outline}
+
+\pagebreak
+
+\subsection{Szóródási mutatók számolása}
+
+\begin{outline}
+	\1 Terjedelem (range): $R = x_n^* - x_1^*$
+	\1 Interkvartilis terjedelem: $IQR = Q_3 - Q_1$
+	\1 Tapasztalati szórás:
+		\2 Átlagtól való átlagos négyzetes eltérés négyzetgyöke
+		\2 Közvetlenül: $S_n = \sqrt{\frac{1}{n}*\sum_{i=1}^{n} (x_i - \overline{x})^2}$
+		\2 Osztályközös gyakoriságból: $S_n = \sqrt{\frac{1}{n}*\sum_{i=1}^{k} f_i (x_i - \overline{x})^2}$
+	\1 Korrigált tapasztalati szórás:
+		\2 Átlagtól való korrigált átlagos négyzetes eltérés négyzetgyöke
+		\2 Ez az alapértelmezett általában
+		\2 Számítás: ugyan az, csak $n$ helyett $n-1$-gyel osztunk (Jele: $S^*_n$)
+		\2 Kis s-sel jelölés jelentése: nem a valószínűségi változóról, hanem a konkrét értékről van szó (nem nagyon számít, csak így helyesebb)
+	\1 Szórási együttható, relatív szórás: $V=S_n/\overline{X}$ ($*100\%$)
+\end{outline}
+
+\pagebreak
+
+\subsection{Grafikus megjelenítés}
+
+\begin{outline}
+	\1 Kördiagram rossz
+\end{outline}
+
+\subsubsection{Hisztogram}
+
+\begin{outline}
+	\1 Osztályok gyakoriságát ábrázolja ($y$ az $f_i$ gyakoriság, $x$ az ismérv)
+	\1 Osztályok száma $k$, hosszuk (ha azonos): $h = \frac{x^*_n - x^*_1}{k}$
+	\1 Sűrűséghisztogram: $g_i = \frac{f_i}{n*h_i}$
+		\2 Relatív gyakoriság / intervallumhossz értéket ábrázoljuk
+		\2 Területarányos, összterület=1
+\end{outline}
+
+\subsubsection{Boxplot ábra (Box \& Whiskers diagram)}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.7\linewidth]{boxplot}
+\end{figure}
+
+\begin{outline}
+	\1 A = $max\{ x^*_1; Q_1 - 1.5 * IQR \}$
+	\1 E = $min\{ x^*_n; Q_3 + 1.5 * IQR \}$
+\end{outline}
+
+\pagebreak
+
+\section{Előadás 8: Matematikai statisztika, becsléselmélet}
+
+\subsection{Matematikai statisztika}
+
+\begin{outline}
+	\1 Minta alapján teljes populáció tulajdonságaira következtetés
+	\1 Paramétertér: $\Theta$ (1 vagy több dimenziós, akár végtelen) ($\vartheta \in \Theta$)
+	\1 Minta: $X = (X_1, X_2, ..., X_n)$ i.i.d. valószínűségi változók sorozata
+		\2 Minta realizációja ($x_1,...,x_n$): konkrét értékeket kap
+	\1 Mintatér: $\mathcal{X} : \mathbb{R}^n$, ide eshetnek a mintaelemek
+	\1 Mintaelemek eloszlása ($F$) ismeretlen, de paraméterezhető: $F_\vartheta$
+	\1 Gyakori feladat: minta alapján adott eloszlás paraméterjének megállapítása
+\end{outline}
+
+\subsection{Becsléselmélet}
+
+\subsubsection{Bevezetés, motiváció}
+
+\begin{outline}
+	\1 Legyen $X$ egy minta
+	\1 Illeszkedésvizsgálat: milyen eloszlású lehet $X$?
+	\1 Pontbecslés: ismert eloszlás esetén mi az eloszlás paramétere?
+		\2 Mintából számoljuk, így valamennyi hiba van benne
+		\2 A kapott eredményben nincs benne, hogy mennyire biztos a becslés
+		\2 Példák erre: Maximum Likelihood, Momentum-módszer
+	\1 Intervallumbecslés: milyen intervalban lesz nagy valószínűséggel $\vartheta$?
+		\2 Csak egyetlen szám helyett egy intervallum az eredmény
+		\2 Intervallum hosszából következtethető, hogy mennyi biztos a becslés
+		\2 Példa erre: konfidenciaintervallum (következő EA)
+\end{outline}
+
+\pagebreak
+
+\subsubsection{Alapdefiníciók}
+
+\begin{outline}
+	\1 Legyen $X = (X_1, ..., X_n)$ i.i.d. minta egy $\vartheta \in \mathbb{R}$ paraméterű eloszláscsaládból
+	\1 $T : \mathcal{X} \to \mathbb{R}$ becslés $\vartheta$-ra
+		\2 Torzítatlan $\Leftrightarrow$ $E_\vartheta(T(X)) = \vartheta$ \;\;\; ($\forall \vartheta \in \Theta$)
+		\2 Aszimptotikusan torzítat $\Leftrightarrow$ $E_\vartheta(T_n(X)) \to \vartheta$ ha $n \to \infty$ ($\forall \vartheta \in \Theta$)
+		\2 Konzisztens $\Leftrightarrow$ $T_n(X) \to \vartheta$ sztochasztikusan ha $n \to \infty$ ($\forall \vartheta \in \Theta$)
+			\3 Elégséges, ha $T_n$ aszimptotikusan torzítatlan és $D^2(T_n) \to 0$
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=1\linewidth]{becslések}
+\end{figure}
+
+\subsubsection{Likelihood függvények}
+
+\begin{outline}
+	\1 Likelihood függvény: $L(\vartheta;x)$
+		\2 Folytonos eloszlás: $L(\vartheta;x) = f_\vartheta(x) = \Pi_{i=1}^n f_\vartheta(x_i)$
+		\2 Diszkrét eloszlás:  $L(\vartheta;x) = P_\vartheta(X=x) = \Pi_{i=1}^n P_\vartheta(X_i = x_i)$
+			\3 $\implies$ $x_i$ gyakorisága $g$, akkor $P_\vartheta(X_i = x_i)^g$-ként jelenik meg
+	\1 Log-likelihood függvény (latex: ell): $\ell(\vartheta;x) = ln(L(\vartheta;x))$
+	\1 $\sum_{i=1}^n x_i$ felírható $n * \overline{x}$ alakban (szebb)
+	\1 $f_\vartheta(x)$-ban van elágazás és $x$ függ $\vartheta$-tól (pl. $0 \le x \le \vartheta$), akkor indikátor fv-t vegyünk be $f_\vartheta$-ba:
+	$...*I(0 \le x_i \le \vartheta) \implies ... * I(0 \le x_1^*) * I(x_n^* \le \vartheta)$
+		\2 Maximumot keresünk $\implies$ indikátor értéke legyen $1$
+\end{outline}
+
+\pagebreak
+
+\subsection{Maximum likelihood becslés (ML-módszer) (pontbecslés)}
+
+\begin{outline}
+	\1 $L(\vartheta;x)$ maximumát keressük (ugyan ott van, mint $\ell(\vartheta;x)$ maximuma)
+	\1 Maximum keresése deriválttal: $\partial_\vartheta \ell(\vartheta;x) = 0$
+		\2 Nem szükséges további ellenőrzés: ahol $0$, ott a max
+		\2 Több dimenziós $\vartheta$ esetén: $\partial_{\vartheta_i} \ell(\vartheta;x) = 0$
+	\1 ML-becslés invariánsa: $\vartheta$ ML becslése $\hat{\vartheta}$ $\implies$ $g(\vartheta)$ ML-becslése $g(\hat{\vartheta})$
+\end{outline}
+
+\subsection{Nevezetes diszkrét eloszlások ML-becslése}
+
+\begin{outline}
+	\1 Egyes vizsgálatokhoz szükségünk lesz eloszlások paraméterének becslésére
+	\1 Binomiális: $p = \frac{\overline{X}}{m} = \frac{0*db_1 + ... + m*db_m}{m * \sum_{i=1}^m db_i}$ ahol $m$ a másik paraméter
+	\1 Poisson: $\lambda = \overline{X} = \frac{1}{n} * \sum_{i=1}^n k_i$
+	ahol $k_i \ge 0$ az érték (nem gyakoriság)
+	\1 Geometriai, Pascal: $\frac{1}{\overline{X}} = \frac{n}{\sum_{i=1}^n k_i}$
+	ahol $k_i \ge 1$ az érték (nem gyakoriság)
+	\1 Negatív binomiális, hipergeometriaia: nem találtam
+\end{outline}
+
+\subsection{Momentum módszer (pontbecslés)}
+
+\begin{outline}
+	\1 Tapasztalati és elméleti momentumokat egyenlővé tesszük
+		\2 Tapasztalati momentum (mintából származik): $m_i = \frac{1}{n} \sum_{j=1}^{n} x_j^i$
+		\2 Elméleti momentum: $M_i(\vartheta) = E_\vartheta(X^i)$
+	\1 $i$ értékei: $1,...,p$ ahol $p$ a $\vartheta$ dimenzióinak száma (egyenletrendszer lesz)
+		\2 Egy dimenziós $\vartheta$ esetén: $\overline{x} = m_1 = M_1 = E_\vartheta(X)$
+		\2 Két dimhez segítség: $E(X^2) = D^2(X) + E^2(X)$ \; ($D^2(X)=...$-ból)
+\end{outline}
+
+\subsection{Becslés hibája, standard hiba}
+
+\begin{outline}
+	\1 Becslés standard hibája a becslés szórása
+	\1 $s.e.(\overline{X}) = \frac{\sigma}{\sqrt{n}}$ \;\; (azaz 0-hoz tart, ahogy az elemszám nő)
+	\1 $\sigma$ ismeretlen $\implies$ becsüljük:
+	$\widehat{s.e.}(\overline{X}) = \frac{\widehat{\sigma}}{\sqrt{n}}$
+		\2 Nem torzítatlan, csak aszimptotikusan
+\end{outline}
+
+\pagebreak
+
+\subsection{Konfidenciaintervallum (intervallumbecslés)}
+
+\begin{outline}
+	\1 Intervallum, ami legalább $1 - \alpha$ valószínűséggel tartalmazza a paramétert minden $\vartheta$ értékre
+		\2 Azaz a valódi $m$ vagy $\sigma$ ekkora valószínűséggel van az intervallumban
+		\2 100 szimulációból kb. $(1-\alpha)*100$-szor lesz az intervallumban
+	\1 Mi elsősorban normál eloszlással fogunk csak dolgozni
+	\1 Emlékeztető: $\frac{\overline{X}-m}{\frac{\sigma}{\sqrt{n}}} \sim N(0;1)$
+	\1 $u_x$ jelentése: $x$-hez tartozó $N(0;1)$ eloszlás kvantilis ($\Phi(u_x) = x$)
+	\1 $t_x$ jelentése: $x$-hez tartozó $n-1$ szabadsági fokú $t$ eloszlás kvantilis
+	\1 Intervallum hossza csökken, ha $n$ nő és ha $\sigma$ csökken
+	\1 Intervallum hossző nő, ha $\alpha$ csökken
+\end{outline}
+
+\subsubsection{Kétoldali $1 - \alpha$ megbízhatóságú konfidenciaintervallum}
+
+\begin{outline}
+	\1 $m$-re, ha $\sigma$ ismert:
+	$\overline{X} \pm u_{1-\frac{\alpha}{2}} * \frac{\sigma}{\sqrt{n}}$
+		\2 \begin{verbatim}
+			ci_also <- mean(sample) - qnorm(1 - alpha / 2) * sigma / sqrt(n)
+			ci_felso <- mean(sample) + qnorm(1 - alpha / 2) * sigma / sqrt(n)\end{verbatim}
+		\2 Szükséges elemszám adott intervallum hosszhoz: \begin{verbatim}
+			hossz <- 8
+			legalabbn <- (2 * qnorm(1 - alpha / 2) * sigma / hossz)^2
+			\end{verbatim}
+	\1 $m$-re, ha $\sigma$ ismeretlen:
+	$\overline{X} \pm t_{n-1;1-\frac{\alpha}{2}} * \frac{S^*_n}{\sqrt{n}}$
+		\2 \begin{verbatim}
+			sd <- sd(sample)
+			ci_also <- mean(sample) - qt(1 - alpha / 2, df=n-1) * sd / sqrt(n)
+			ci_felso <- mean(sample) + qt(1 - alpha / 2, df=n-1) * sd / sqrt(n)\end{verbatim}
+	\1 $\sigma^2$-re: $[ \frac{(n-1) * (S^*_n)^2}{\chi^2_{n-1;1-\frac{\alpha}{2}}}
+	; \frac{(n-1) * (S^*_n)^2}{\chi^2_{n-1;\frac{\alpha}{2}}} ]$
+\end{outline}
+
+\pagebreak
+
+\subsubsection{Egyoldali, alsó, $1 - \alpha$ megbízhatóságú konfidenciaintervallum}
+
+\begin{outline}
+	\1 $m$-re, ha $\sigma$ ismert:
+	$(-\infty; \overline{X} + u_{1-\alpha} * \frac{\sigma}{\sqrt{n}})$
+		\2 \begin{verbatim}
+			ci_felso <- mean(sample) + qnorm(1 - alpha) * sigma / sqrt(n)\end{verbatim}
+		\2 Szükséges elemszám adott intervallum hosszhoz: \begin{verbatim}
+			hossz <- 8
+			legalabbn <- (2 * qnorm(1 - alpha) * sigma / hossz)^2
+			\end{verbatim}
+	\1 $m$-re, ha $\sigma$ ismeretlen:
+	$(-\infty; \overline{X} + t_{n-1;1-\alpha} * \frac{S^*_n}{\sqrt{n}})$
+		\2 \begin{verbatim}
+			sd <- sd(sample)
+			ci_felso <- mean(sample) + qt(1 - alpha, df=n-1) * sd / sqrt(n)\end{verbatim}
+	\1 $\sigma^2$-re: $(0; \frac{(n-1) * (S^*_n)^2}{\chi^2_{n-1;\alpha}})$
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.5\linewidth]{konfidenciaintervallum}
+\end{figure}
+
+\pagebreak
+
+\section{Előadás 9: Hipotézisvizsgálat, próbák}
+
+\subsection{Hipotézisvizsgálat}
+
+\begin{outline}
+	\1 Hipotézis: állítás aminek igazságát vizsgálni szeretnénk: elfogadjuk/elutasítjuk
+	\1 Paraméterteret diszjunkt részekre bontjuk: $\Theta = \Theta_0 \cup^* \Theta_1$
+	\1 Nullhipotézis: $H_0 : \vartheta \in \Theta_0$\\
+	Ellenhipotézis, alternatív hipotézis: $H_1 : \vartheta \in \Theta_1$
+	\1 Nullhipotézist nem "elfogadjuk", hanem "nem tudjuk elvetni".\\
+	Viszont elutasítani el tudjuk.
+	\1 Nullhipotézis megválasztása: sok éves tapasztalatnak feleljen meg, reméljük teljesülését, aminek elutasítása negatív következménnyel jár (pl. bírság)
+		\2 Az ellenhipotézis a lényeg, arról fogunk dönteni.
+		\2 Egyenlőségjel mindig a nullhipotézisbe kerül.
+	\1 Próba: segítségével döntés hozás a hipotézisről
+		\2 Statisztikai próba vagy próba: minta alapján hozunk döntést
+		\2 Paraméteres próba: eloszlás típusa ismert, a nullhipotézis az eloszlás paraméterére (vagy annak egy függvényére) vonatkozik
+			\3 Továbbiakban ezzel fogunk általában foglalkozni
+			\3 Továbbiakban legyen $\Theta \subset \mathbb{R}$, azaz a paraméter valós
+	\1 Mintateret diszjunkt részekre bontjuk: $\chi = \chi_e \cup^* \chi_k$
+		\2 $\chi_k$, kritikus tartomány: megfigyelések, amikre elutasítjuk $H_0$-t
+		\2 $\chi_e$, elfogadási tartomány: megfigyelések, amikre elfogadjuk $H_0$-t
+	\1 Döntési mátrix hipotézisvizsgálat esetén:
+\end{outline}
+
+\begin{table}[h]
+	\centering
+	\begin{tabular}{|c|c|c|}
+		\hline
+		$\downarrow$ valóság | döntés $\to$ & elfogadjuk ($\chi_e$) & elutasítjuk ($\chi_k$) \\
+		\hline
+		$H_0$ teljesül ($\Theta_0$) & helyes döntés & elsőfajú hiba \\
+		\hline
+		$H_0$ nem teljesül ($\Theta_1$) & másodfajú hiba & helyes döntés \\
+		\hline
+	\end{tabular}
+\end{table}
+
+\pagebreak
+
+\subsection{Hiba valószínűségek, erőfüggvény, terjedelem}
+
+\begin{outline}
+	\1 Elsőfajú hiba valószínűsége:
+		\2 Egyszerű $H_0$, $|\Theta_0| = 1$:
+		$\alpha(\vartheta) = P_\vartheta(X \in \chi_k) = P_0(\chi_k)$
+		\;\; ($\vartheta \in \Theta_0$)
+		\2 Összetett $H_0$, $|\Theta_0| > 1$:
+		$\alpha \ge P_\vartheta(X \in \chi_k)$ \;\; ($\forall \vartheta \in \Theta_0$)
+	\1 Másodfajú hiba valószínűsége:
+	\\$\beta(\vartheta) = P_\vartheta(X \in \chi_e) = P_1(\chi_e)
+		= 1 - P_\vartheta(\chi_k)$ \;\; ($\vartheta \in \Theta_1$)
+	\1 Erőfüggvény: $\psi(\vartheta) = 1 - P_\vartheta(\chi_e) = P_\vartheta(\chi_k)$
+	ahol $\vartheta \in \Theta_1$
+		\2 Jelentése: valószínűsége $H_0$ elvetésének, amikor az hamis
+		\2 Valószínűsége annak, hogy egy adott különbséget egy adott mintanagyság és terjedelem mellett ki egy statisztikai próba kimutat
+	\1 Terjedelem, pontos terjedelem, szignifikanciaszint: $\alpha = \sup_{\vartheta \in \Theta_0} \alpha(\vartheta)$
+		\2 Általában feladat elejekor 5\%-on (vagy 1\% és 10\% között) rögzített
+		\2 Megbízhatósági szint, konfidenciaszint: $1 - \alpha$ \; ($*100\%$)
+			\3 Valószínűsége, hogy $H_0$-t elfogadjuk, amikor az igaz
+		\2 Másképp: elsőfajú hiba valószínűsége $\alpha$ lesz
+\end{outline}
+
+\subsection{Próbák bevezetés}
+
+\begin{outline}
+	\1 Kétoldali próba: $H_0: \vartheta = \vartheta_0$ és $H_1: \vartheta \ne \vartheta_0$
+	\1 Egyoldali próba: $H_0: \vartheta = \vartheta_0$ és $H_1: \vartheta < \vartheta_0$ (vagy >)
+	\1 Próbastatisztika: alkalmas T statisztika, amivel a $\chi_k$-t meghatározzuk
+		\2 Kétoldali próbához: $\chi_k = \{ x \in \chi \;:\; |T(X)| > c \}$
+		\2 Egyoldali próbához: $\chi_k = \{ x \in \chi \;:\; T(X) \lessgtr c \}$
+		\2 $c$ neve: kritikus érték
+			\3 Jellemzően függ a próba terjedelmétől $\implies$ $c_\alpha$-val jelöljük
+			\3 $c_\alpha$ jelölés jelentése: $c_\alpha$ a $T(X)$ val. változó $\alpha$-kvantilise
+		\2 Próba meghatározása: előre rögzített $\alpha$ terjedelemhez keressük azt a $c_\alpha$ értéket, amire a próba pontos terjedelme éppen $\alpha$
+			\3 $\sup_{\vartheta \in \Theta_0} P_\vartheta(T(X) > c_\alpha) = \alpha$
+\end{outline}
+
+\pagebreak
+
+\subsection{Hipotézisvizsgálat menete}
+
+\begin{outline}
+	\1 Terjedelem ($\alpha$) lefixálása, általában 5\%-on (megbízhatóság: $1 - \alpha$)
+	\1 Nullhipotézis: sokévi tapasztalatnak megfelelő paramétertartomány
+		\2 Az egyenlőség (pl. $\le$) mindig ide kerül
+	\1 Alternatív hipotézis: feladat kérdéséhez megfelelő paramétertartomány
+		\2 Erről be tudjuk látni, hogy igaz ($H_0$-ról csak "nem tudjuk elvetni")
+		\2 Ezért a cél $H_1$ igazolása, azaz $H_0$ elvetése
+	\1 Problémához alkalmas próba/próbák választása (egy/két oldali, stb.)
+	\1 Próbastatisztika kiszámítása
+\end{outline}
+
+\subsubsection{Döntés minta és tartományok alapján}
+
+\begin{outline}
+	\1 Kritikus érték kiszámítása, kritikus tartomány megállapítása
+		\2 Számolása általában: eloszlás kvantilis függvény "meghívása" $\alpha$-ra
+	\1 $x \in \chi_k \;\;\Leftrightarrow\;\; H_1\text{-et elfogadjuk}$
+	\1 Probléma: nem derül ki, hogy mennyire voltunk közel az elfogadáshoz
+\end{outline}
+
+\subsubsection{Döntés p-érték segítségével}
+
+\begin{outline}
+	\1 p-érték kiszámolása (számítógépes számolás esetén lehetőség)
+		\2 Számolása általában: eloszlásfüggvény "meghívása" próbastatisztikával
+		\2 Kétoldali próba esetén bonyolultabb (általában: $2*pDist(-|T|)$)
+	\1 $p\text{-érték} < \alpha \;\;\Leftrightarrow\;\; x \in \chi_k
+	\;\;\Leftrightarrow\;\; H_1\text{-et elfogadjuk}$
+	\1 p-érték jelentése: terjedelem, amire a kritikus érték megegyezik a próbastatisztikával
+		\2 Máshogy: legkisebb $\alpha$, amire az adott minta esetén elvetjük $H_0$-t
+		\2 Máshogy: igaz $H_0$ mellett annak a valószínűsége, hogy a tapasztalt eltérést, vagy annál nagyobb eltérést kapunk
+\end{outline}
+
+\subsubsection{Elsőfajú, másodfajú hiba csökkentése}
+
+\begin{outline}
+	\1 $\alpha$ csökkentése $\beta$ növekedésével jár (ha minden más marad)
+	\1 Mindkét hiba valószínűségének csökkentése: mintaelemszám növelése
+\end{outline}
+
+\pagebreak
+
+\section{Előadás 10: Próbák normális eloszlás paramétereire}
+
+\subsection{Használt jelölések, emlékeztetők}
+
+\begin{outline}
+	\1 Emlékeztető: $\frac{\overline{X}-m}{\frac{\sigma}{\sqrt{n}}}
+	= \sqrt{n} * \frac{\overline{X}-m}{\sigma} \sim N(0;1)$
+	\1 $u_x$ jelentése: $x$-hez tartozó $N(0;1)$ eloszlás kvantilis ($\Phi(u_x) = x$)
+	\1 $t_x$ jelentése: $x$-hez tartozó $n-1$ szabadsági fokú $t$ eloszlás kvantilis
+	\1 $S^*_n$ jelentése: korrigált tapasztalati szórás, $S^*_n = \sqrt{\frac{1}{n-1}*\sum_{i=1}^{n} (x_i - \overline{x})^2}$
+\end{outline}
+
+\subsection{Próbákról tudnivalók}
+
+\begin{outline}
+	\1 Kétmintás próba: két (összefüggő vagy független) mintánk van
+	\1 Összefüggő (párosított) minták: vettünk egy mintát, valami megváltozott
+	(pl. gépen valamit állítottunk) és veszünk még egy mintát ugyan onnan
+		\2 Cél: változtatás hatásának vizsgálata (pl. működik-e a gyógyszer)
+	\1 Kétoldali próba: egyenlőséget ellenőrzünk (pl. $m$ tényleg az-e)
+	\1 Egyoldali próba: gyanúnk, hogy pl. $m$ valaminél kisebb/nagyobb
+\end{outline}
+
+\pagebreak
+
+\subsection{Próbák normális eloszlás várható értékére ($m$)}
+
+\begin{outline}
+	\1 Egymintás próba
+		\2 Szórás ismert: \hyperref[sec:próba-1minta-u]{egymintás u-próba}
+		\2 Szórás ismeretlen: \hyperref[sec:próba-1minta-t]{egymintás t-próba}
+	\1 Kétmintás próba, két minta független
+		\2 Szórások ismertek: \hyperref[sec:próba-2minta-u]{kétmintás u-próba}
+		\2 Szórások ismeretlenek: előzetes \hyperref[sec:próba-F]{F-próba} szükséges
+			\3 Szórások megegyeznek: \hyperref[sec:próba-2minta-t]{kétmintás t-próba}
+			\3 Szórások eltérnek: \hyperref[sec:próba-welch]{Welch-próba}
+	\1 Kétmintás próba, két minta párosított (összefüggő)
+		\2 Szórások ismertek: \hyperref[sec:próba-1minta-u]{egymintás u-próba} a különbségekre
+		\2 Szórások ismeretlenek: \hyperref[sec:próba-1minta-t]{egymintás t-próba} a különbségekre
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=1\linewidth]{paraméteres-próba-választás}
+\end{figure}
+
+\pagebreak
+
+\subsubsection{Egymintás u-próba (z-test)}
+\label{sec:próba-1minta-u}
+
+\begin{outline}
+	\1 $X_1,...,X_n \sim N(m,\sigma^2)$ ahol $\sigma$ ismert és $m=?$
+	\1 Próbastatisztika: $T(X) = u = \sqrt{n}*\frac{\overline{X} - m_0}{\sigma}$
+	\;\; ($H_0$ esetén $u \sim N(0,1)$)
+		\2 \texttt{u <- sqrt(n) * (mean(sample) - mu0) / sigma}
+	\1 Kétoldali: $H_0: m = m_0$ és $H_1: m \ne m_0$
+	és $\chi_k = \{ x \;:\; |u| > u_{1-\alpha/2} \}$
+		\2 \texttt{pertek <- 2*pnorm(-abs(u))}
+		\2 \texttt{krit <- qnorm(c(alpha/2, 1-alpha/2)) \#1.alatt és 2.felett}
+	\1 Egyoldali: $H_0: m = m_0$ és
+		\2 $H_1: m < m_0$ és $\chi_k = \{ x \;:\; u < u_{\alpha} \}$
+			\3 \texttt{pertek <- pnorm(u)}
+			\3 \texttt{krit <- qnorm(alpha)}
+		\2 $H_1: m > m_0$ és $\chi_k = \{ x \;:\; u > u_{1-\alpha} \}$
+			\3 \texttt{pertek <- pnorm(-u)}
+			\3 \texttt{krit <- qnorm(1-alpha)}
+	\1 Kapcsolat konfidenciaintervallummal:
+		\2 $|u| > u_{1-\alpha/2} \;\;\Leftrightarrow\;\; m_0 \notin
+		(\overline{X} - u_{1-\alpha/2}*\frac{\sigma}{\sqrt{n}},\;\;
+		\overline{X} + u_{1-\alpha/2}*\frac{\sigma}{\sqrt{n}})$
+		\2 Máshogy: $H_0$-t pontosan akkor utasítjuk el, ha az $1-\alpha$ konfidenciaintervallum nem tartalmazza $m_0$-t
+	\1 \begin{verbatim}
+	library(TeachingDemos)
+	z.test(x, alternative = c("two.sided/less/greater"),
+	       mu = mu0, stdev = sigma, conf.level = 1 - alpha)
+	\end{verbatim}
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=1\linewidth]{kritikus-tartományok}
+\end{figure}
+
+\pagebreak
+
+\subsubsection{Egymintás t-próba (Student's t-test)}
+\label{sec:próba-1minta-t}
+
+\begin{outline}
+	\1 $X_1,...,X_n \sim N(m,\sigma^2)$ ahol $\sigma$ és $m$ ismeretlen; $m=?$
+	\1 Próbastatisztika: $T(X) = t = \sqrt{n}*\frac{\overline{X} - m_0}{S^*_n}$
+	\;\; ($H_0$ esetén $t \sim t_{n-1}$)
+		\2 \texttt{t <- sqrt(n) * (mean(sample) - mu0) / sd(sample)}
+	\1 Kétoldali: $H_0: m = m_0$ és $H_1: m \ne m_0$
+	és $\chi_k = \{ x \;:\; |t| > t_{n-1,1-\alpha/2} \}$
+		\2 \texttt{pertek <- 2*pt(-abs(t), df=n-1)}
+		\2 \texttt{krit <- qt(c(alpha/2, 1-alpha/2), df=n-1) \#1.alatt és 2.felett}
+	\1 Egyoldali: $H_0: m = m_0$ és 
+		\2 $H_1: m < m_0$ és $\chi_k = \{ x \;:\; t < t_{n-1,\alpha} \}$
+			\3 \texttt{pertek <- pt(t, df=n-1)}
+			\3 \texttt{krit <- qt(alpha, df=n-1)}
+		\2 $H_1: m > m_0$ és $\chi_k = \{ x \;:\; t > t_{n-1,1-\alpha} \}$
+			\3 \texttt{pertek <- pt(-t, df=n-1)}
+			\3 \texttt{krit <- qt(1-alpha, df=n-1)}
+	\1 \begin{verbatim}
+	t.test(x, alternative = "two.sided/less/greater",
+	       mu = mu0, conf.level = 1 - alpha)
+	\end{verbatim}
+\end{outline}
+
+\pagebreak
+
+\subsubsection{Kétmintás u-próba}
+\label{sec:próba-2minta-u}
+
+\begin{outline}
+	\1 Független minták: $X_{1..n} \sim N(m_1, \sigma_1^2)$ és $Y_{1..m} \sim N(m_2, \sigma_2^2)$
+		\2 $\sigma_1$, $\sigma_2$ ismert és $m_1$, $m_2$ ismeretlen (relációjuk a kérdés)
+	\1 Próbastatisztika: $T(X,Y) = u = (\overline{X} - \overline{Y}) / \sqrt{\frac{\sigma_1^2}{n} + \frac{\sigma_2^2}{m}}$
+		\2 $H_0$ esetén $u \sim N(0,1)$
+		\2 \begin{verbatim}
+		u <- (mean(sampleA) - mean(sampleB))
+		      / sqrt(sigmaA^2/n + sigmaB^2/m)
+		\end{verbatim}
+	\1 Kétoldali: $H_0: m_1 = m_2$; $H_1: m_1 \ne m_2$
+	és $\chi_k = \{ (x,y) : |u| > u_{1-\alpha/2} \}$
+		\2 \texttt{pertek <- 2*pnorm(-abs(u))}
+		\2 \texttt{krit <- qnorm(c(alpha/2, 1-alpha/2)) \#1.alatt és 2.felett}
+	\1 Egyoldali: $H_0: m_1 = m_2$ és 
+		\2 $H_1: m_1 < m_2$ és $\chi_k = \{ (x,y) \;:\; u < u_{\alpha} \}$
+			\3 \texttt{pertek <- pnorm(u)}
+			\3 \texttt{krit <- qnorm(alpha)}
+		\2 $H_1: m_1 > m_2$ és $\chi_k = \{ (x,y) \;:\; u > u_{1-\alpha} \}$
+			\3 \texttt{pertek <- pnorm(-u)}
+			\3 \texttt{krit <- qnorm(1-alpha)}
+	\1 \begin{verbatim}
+	two_sample_u_test <- function(sampleA, sampleB, sigmaA, sigmaB,
+	                              alternative, conf_level) {
+	  alpha <- 1 - conf_level; n <- length(sampleA); m <- length(sampleB)
+	  u <- (mean(sampleA) - mean(sampleB)) / sqrt(sigmaA^2 / n + sigmaB^2 / m)
+	  if (alternative == "t" || alternative == "two.sided") {
+	    krit <- qnorm(c(alpha/2, 1 - alpha/2)); pertek <- 2 * pnorm(-abs(u))
+	  } else if (alternative == "l" || alternative == "less") {
+	    krit <- qnorm(alpha); pertek <- pnorm(u)
+	  } else if (alternative == "g" || alternative == "greater") {
+	    krit <- qnorm(1 - alpha); pertek <- pnorm(-u)
+	  } else { cat("Invalid alternative: " + alternative); return() }
+	  cat("Próbastatisztika:", u,
+	      "\nKritikus tartomány:", krit[1], "alatt és", krit[2], "felett",
+	      "\nP-érték:", pertek, "\nDöntés:", if (pertek < alpha)
+	         { "H0 elutasítva" } else { "H0-t nem sikerült elvetni" }, "\n")
+	} %sampleA, sampleB sorrendje: lásd jegyzet PDF, kétmintás t-próba
+	\end{verbatim}
+\end{outline}
+
+\pagebreak
+
+\subsubsection{Kétmintás t-próba}
+\label{sec:próba-2minta-t}
+
+\begin{outline}
+	\1 Független minták: $X_{1..n} \sim N(m_1, \sigma_1^2)$ és $Y_{1..m} \sim N(m_2, \sigma_2^2)$
+		\2 $\sigma_1 = \sigma_2$ ismeretlen és $m_1$, $m_2$ ismeretlen (relációjuk a kérdés)
+	\1 Próbastatisztika: $T(X,Y) = t = \sqrt{\frac{n*m}{n+m}} * (\overline{X} - \overline{Y}) / \sqrt{\frac{(n-1)(S^*_1)^2+(m-1)(S^*_2)^2}{n+m-2}}$
+		\2 $H_0$ esetén $t \sim t_{n+m-2}$
+		\2 \begin{verbatim}
+		t <- sqrt((n*m)/(n+m)) * (mean(sampleA) - mean(sampleB))
+		/ sqrt( ((n-1)*sd(sampleA)^2 + (m-1)*sd(sampleB)^2) / (n+m-2) )
+		\end{verbatim}
+	\1 Kétoldali: $H_0: m_1 = m_2$ és $H_1: m_1 \ne m_2$\\
+	és $\chi_k = \{ (x,y) : |t| > t_{n+m-2,1-\alpha/2} \}$
+	\1 Egyoldali: $H_0: m_1 = m_2$ és 
+		\2 $H_1: m_1 < m_2$ és $\chi_k = \{ (x,y) \;:\; t < t_{n+m-2,\alpha} \}$
+			\3 \texttt{pertek <- pt(t)}
+			\3 \texttt{krit <- qt(alpha)}
+		\2 $H_1: m_1 > m_2$ és $\chi_k = \{ (x,y) \;:\; t > t_{n+m-2,1-\alpha} \}$
+			\3 \texttt{pertek <- pt(-t)}
+			\3 \texttt{krit <- qt(1-alpha)}
+	\1 \begin{verbatim}
+	t.test(sampleA, sampleB, alternative="two.sided/less/greater",
+	       paired=FALSE, var.equal=TRUE)
+	\end{verbatim}
+		\2 A minta sorrend és a reláció egyezzen meg az ellenhipotézissel
+		\2 Ez a kettő ekvivalens: sampleA,sampleB,less $\Leftrightarrow$ sampleB,sampleA,greater
+\end{outline}
+
+\pagebreak
+
+\subsubsection{Welch-próba}
+\label{sec:próba-welch}
+
+\begin{outline}
+	\1 Független minták: $X_{1..n} \sim N(m_1, \sigma_1^2)$ és $Y_{1..m} \sim N(m_2, \sigma_2^2)$
+		\2 $\sigma_1 \ne \sigma_2$ ismeretlen és $m_1$, $m_2$ ismeretlen (relációjuk a kérdés)
+	\1 Próbastatisztika: $T(X,Y) = t' = (\overline{X} - \overline{Y}) / \sqrt{\frac{(S^*_1)^2}{n}+\frac{(S^*_2)^2}{m}}$
+		\2 $H_0$ esetén $t' \sim t_f$
+		ahol $\frac{1}{f} = \frac{c^2}{n-1} + \frac{(1-c)^2}{m-1}$
+		\2 $S^*_1 > S^*_2$ (így válasszuk) $\implies
+		c = (\frac{(S^*_1)^2}{n}) / ( \frac{(S^*_1)^2}{n} + \frac{(S^*_2)^2}{m} )$
+	\1 Kétoldali: $H_0: m_1 = m_2$ és $H_1: m_1 \ne m_2$\\
+	és $\chi_k = \{ (x,y) : |t'| > t_{f,\alpha/2} \}$
+	\1 Egyoldali: $H_0: m_1 = m_2$ és 
+		\2 $H_1: m_1 < m_2$ és $\chi_k = \{ (x,y) \;:\; t < -t_{f,\alpha} \}$
+		\2 $H_1: m_1 > m_2$ és $\chi_k = \{ (x,y) \;:\; t > t_{f,\alpha} \}$
+	\1 \begin{verbatim}
+	t.test(sampleA, sampleB, alternative="two.sided/less/greater",
+	       paired=FALSE, var.equal=FALSE)
+	\end{verbatim}
+		\2 Két minta (sampleA, sampleB) sorrendje: lásd kétmintás t-próba
+\end{outline}
+
+\pagebreak
+
+\subsection{Próbák normális eloszlás szórásnégyzetére ($\sigma^2$)}
+
+\begin{outline}
+	\1 Gyakorlaton nem foglalkozunk ilyennel, kivéve az (előzetes) F-próba
+	\1 Egymintás próba: \hyperref[sec:próba-chi2]{$\chi^2$-próba}
+	\1 Kétmintás próba: \hyperref[sec:próba-F]{F-próba}
+\end{outline}
+
+\subsubsection{F-próba}
+\label{sec:próba-F}
+
+\begin{outline}
+	\1 Független minták: $X_{1..n} \sim N(m_1, \sigma_1^2)$ és $Y_{1..m} \sim N(m_2, \sigma_2^2)$
+		\2 $m_1$, $m_2$ ismeretlen és $\sigma_1$, $\sigma_2$ ismeretlen (relációjuk a kérdés)
+	\1 Próbastatisztika: $T(X,Y) = F = \frac{(S^*_2)^2}{(S^*_1)^2}$ \; ha $S^*_1 < S^*_2$
+		\2 $H_0$ esetén $F \sim F_{n-1,m-1}$
+	\1 Kétoldali: $H_0: \sigma_1 = \sigma_2$ és $H_1: \sigma_1 \ne \sigma_2$
+		\2 vagy $\chi_k = \{ (x,y) : F < F_{n-1,m-1,\alpha/2} \}$
+		\2 vagy $\chi_k = \{ (x,y) : F > F_{n-1,m-1,1-\alpha/2} \}$
+		\2 Attól függ, hogy $S_1^*$ vagy $S_2^*$ a nagyobb
+	\1 Egyoldali: $H_0: \sigma_1 = \sigma_2$ és 
+		\2 $H_1: \sigma_1 < \sigma_2$ és $\chi_k = \{ (x,y) \;:\; F < F_{n-1,m-1,\alpha} \}$
+		\2 $H_1: \sigma_1 > \sigma_2$ és $\chi_k = \{ (x,y) \;:\; F > F_{n-1,m-1,1-\alpha} \}$
+	\1 Előzetes F-próba:
+		\2 Mindig kétoldali
+		\2 Nem számít a minták sorrendje (p-érték nem változik)
+		\2 p-érték nagy $\implies$ nincs bizonyíték, hogy különböznek a szórások
+			\3 Ha nem tudunk dönteni, inkább tekintsük a szórásokat egyenlőnek
+		\2 \texttt{var.test(mintaA, mintaB, alternative="two.sided")}
+		\2 \begin{verbatim}
+		f <- sd(mintaA)^2 / sd(mintaB)^2
+		pertek <- 2 * pf(f, df1 = length(mintaA) - 1,
+		                    df2 = length(mintaB) - 1)
+		\end{verbatim}
+\end{outline}
+
+\pagebreak
+
+\subsubsection{$\chi^2$-próba}
+\label{sec:próba-chi2}
+
+\begin{outline}
+	\1 $X_1,...,X_n \sim N(m,\sigma^2)$ ahol $\sigma$ és $m$ ismeretlen; $\sigma=?$
+	\1 Próbastatisztika: $T(X) = h = \frac{(n-1)(S^*_n)^2}{\sigma_0^2}$
+	\;\; ($H_0$ esetén $h \sim \chi^2_{n-1}$)
+	\1 Kétoldali: $H_0: \sigma = \sigma_0$ és $H_1: \sigma \ne \sigma_0$
+		\2 vagy $\chi_k = \{ x \;:\; h < \chi^2_{n-1,\alpha/2} \}$
+		\2 vagy $\chi_k = \{ x \;:\; h > \chi^2_{n-1,1-\alpha/2} \}$
+		\2 Attól függ, hogy $S_1^*$ vagy $S_2^*$ a nagyobb
+	\1 Egyoldali: $H_0: m = m_0$ és 
+		\2 $H_1: \sigma < \sigma_0$ és $\chi_k = \{ x \;:\; h < \chi^2_{n-1,\alpha} \}$
+		\2 $H_1: \sigma > \sigma_0$ és $\chi_k = \{ x \;:\; h > \chi^2_{n-1,1-\alpha} \}$
+	\1 Nem tételezünk fel normális eloszlást (a mintáról)
+	\1 TODO teljes eseményrendszerről a dolgok
+	\1 Alkalmazások: TODO
+	\1 Nincs minden osztályban elég mennyiség: R adhat warning-ot
+		\2 Ökölszabály: min. 5db minden osztályban ($n*p$ szorzás után)
+		\2 Ha nincs elég, akkor vonjunk össze osztályokat:
+			\3 \begin{verbatim}
+			chisq.test(c(gyakorisag[1:3], sum(gyakorisag[4:5])),
+			    p = c(p[1:3], sum(p[4:5]))) #utolsó 2 összevonva\end{verbatim}
+			\3 \begin{verbatim}
+			tbl2 <- cbind(tbl1[,"Left"] + tbl1[,"Neither"], tbl1[,"Right"])
+			colnames(tbl2) <- c("Left+Neither", "Right")\end{verbatim}
+\end{outline}
+
+\pagebreak
+
+\section{Előadás 11: illeszkedés-, homogenitás- és\\
+függetlenségvizsgálat; regresszióelemzés}
+
+\subsection{Diszkrét illeszkedésvizsgálat ($\chi^2$-próba)}
+
+\begin{outline}
+	\1 $H_0$: minta egy adott eloszlásból származik (valószínűségek egyeznek)
+	\1 $H_1$: minta nem ilyen eloszlású (min 1x: várt, tap. valószínűségek $\ne$)
+	\2 Próbastat.: $T_n(X) = \sum_{i=1}^{r} \frac{(N_i - np_i)^2}{np_i} \to \chi^2_{r-1}$
+	(ha $H_0$ és $n \to \infty$)
+	\2 Kritikus tartomány: $\chi_k = \{ x \;|\; T_n(x) > \chi^2_{r-1,1-\alpha} \}$
+	\1 Tiszta illeszkedésvizsgálat: feltételezett eloszlás ismert
+	\1 Becsléses illeszkedésvizsgálat: eloszlás paramétere ismeretlen
+		\2 ML-módszerrel $s$ darab paramétert meg kell becsülni
+		\2 Próbastatisztika ekkor $H_0$ esetén $\chi^2_{r-1-s}$-be tart
+\end{outline}
+
+\begin{table}[h]
+	\centering
+	\begin{tabular}{|c|c|c|c|c|}
+		\hline
+		Osztály & 1 & ... & r & Összesen \\
+		\hline
+		Gyakoriság & $v_1$ & ... & $v_r$ & n \\
+		\hline
+		Valószínűség & $p_1$ & ... & $p_r$ & 1 \\
+		\hline
+	\end{tabular}
+\end{table}
+
+\subsubsection{Diszkrét illeszkedésvizsgálat R-ben egyszerűen}
+
+\begin{outline}
+	\1 Legyen \texttt{gyakorisag} és \texttt{fejek\_szama} egy-egy vektor
+	\1 Példa p-re: \texttt{p <- dbinom(fejek\_szama, size = 4, p = 0.25)}
+	\1 \texttt{chisq.test(gyakorisag, p = p)}
+\end{outline}
+
+\subsubsection{Diszkrét illeszkedésvizsgálat R-ben manuálisan}
+
+\begin{verbatim}
+s <- 0 #Becsült paraméterek száma
+probastat <- sum((gyakorisag - p * sum(gyakorisag))^2 / (p * sum(gyakorisag)))
+pertek <- 1 - pchisq(probastat, length(gyakorisag) - 1 - s)
+cat('Próbastatisztika:', probastat,
+    '\nKritikus érték', qchisq(1 - alpha, length(gyakorisag) - 1 - s),
+    '\nP-érték:', pertek,
+    '\nDöntés:', if (pertek < alpha) { 'H0 elutasítva' }
+    else { 'H0-t nem sikerült elvetni' }, '\n')\end{verbatim}
+
+\subsection{Folytonos illeszkedésvizsgálat Kolmogorov-Szmirnov próbával}
+
+\begin{outline}
+	\1 TODO 11. előadás 5. oldal
+	\1 Gyakorlaton nem vettük, ZH-ban benne volt
+\end{outline}
+
+\subsection{Homogenitásvizsgálat}
+
+\begin{outline}
+	\1 Két független minta, 1 közös szemponttal $r$ osztályba soroljuk őket
+	\1 $H_0$: két eloszlás megegyezik ($p_i = q_i$)
+	\1 $H_1$: két eloszlás nem egyezik meg (legalább egy helyen)
+	\1 Próbastatisztika: $nm \sum_{i=1}^{r} \frac{(N_i/n-M_i/m)^2}{N_i+M_i} \to \chi^2_{r-1}$
+	(ha $H_0$ és $n \to \infty$)
+	\1 Kritikus tartomány: $\chi_k = \{(X,Y) \;:\; T_{n,m}(X,Y) > \chi^2_{r-1,1-\alpha}\}$
+\end{outline}
+
+\begin{table}[h]
+	\centering
+	\begin{tabular}{|c|c|c|c|c|}
+		\hline
+		Osztály & 1 & ... & r & Összesen \\
+		\hline
+		1. minta: gyakoriság & $N_1$ & ... & $N_r$ & n \\
+		\hline
+		1. minta: valószínűség & $p_1$ & ... & $p_r$ & 1 \\
+		\hline
+		2. minta: gyakoriság & $\mu_1$ & ... & $\mu_r$ & m \\
+		\hline
+		2. minta: valószínűség & $M_1$ & ... & $M_r$ & 1 \\
+		\hline
+	\end{tabular}
+\end{table}
+
+\subsubsection{Homogenitásvizsgálat R-ben}
+
+\begin{outline}
+	\1 \texttt{chisq.test(matrix(c(15, 10, 10, 10), ncol=2, byrow=TRUE))}
+		\2 Értelmes táblázat/mátrix kezelés: lásd R jegyzet (lejjebb)
+\end{outline}
+
+\subsubsection{Homogenitásvizsgálat R-ben manuálisan}
+
+\begin{verbatim}
+n <- sum(x); m <- sum(y)
+probastat <- n * m * sum((x / n - y / m)^2 / (x + y))
+pertek <- 1 - pchisq(probastat, length(x) - 1)
+cat('Próbastatisztika:', probastat,
+    '\nKritikus érték', qchisq(1 - alpha, length(x) - 1),
+    '\nP-érték:', pertek,
+    '\nDöntés:', if (pertek < alpha) { 'H0 elutasítva' }
+    else { 'H0-t nem sikerült elvetni' }, '\n')\end{verbatim}
+
+\pagebreak
+
+\subsection{Függetlenségvizsgálat}
+
+\begin{outline}
+	\1 Egy mintát két szempont alapján osztályokba sorolunk
+		\2 Táblázat: osztály-osztály metszet gyakoriság van benne
+	\1 $H_0$: két szempont független egymástól ($p_{i,j} = p_{i \circ} * p_{\circ j}$)
+	\1 $H_1$: két szempont nem független (nincs egyenlőség legalább egy helyen)
+	\1 Próbastatisztika: $\sum_{i=1}^{r} \sum_{j=1}^{s}
+	\frac{(N_{i,j} - N_{i \circ} N_{\circ j} / n)^2} { N_{i \circ} N_{\circ j} / n }
+	\to \chi^2_{(r-1)(s-1)}$\\
+	($H_0$ és $n \to \infty$ esetén)
+	\1 Kritikus tartomány: $\chi_k = \{ (X,Y) \;:\; T_n(X,Y) > \chi^2_{(r-1)(s-1),1-\alpha} \}$
+	\1 $r=s=2$ esetén
+		\2 Próbastatisztika: $T_n = n \frac{(N_{11}N_{22} - N_{12}N_{21})^2}
+		{N_{1\circ} N_{2\circ} N_{\circ 1} N_{\circ 2}}$
+		\2 Szabadsági foka $\chi^2$-nek pedig 1
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.7\linewidth]{függetlenségvizsgálat}
+\end{figure}
+
+\subsubsection{Függetlenségvizsgálat R-ben}
+
+\begin{outline}
+	\1 \texttt{chisq.test(matrix(c(15, 10, 10, 10), ncol=2, byrow=TRUE))}
+		\2 Értelmes táblázat/mátrix kezelés: lásd R jegyzet (lejjebb)
+\end{outline}
+
+\pagebreak
+
+\subsubsection{Függetlenségvizsgálat R-ben manuálisan}
+
+\begin{verbatim}
+rows <- nrow(tablazat); cols <- ncol(tablazat)
+probastat <- 0; for (i in 1:rows) for (j in 1:cols) {
+  tmp <- sum(tablazat[i,]) * sum(tablazat[, j]) / sum(tablazat)
+  probastat <- probastat + (tablazat[i, j] - tmp)^2 / tmp }
+pertek <- 1 - pchisq(probastat, (rows - 1) * (cols - 1))
+cat('Próbastatisztika:', probastat,
+    '\nKritikus érték', qchisq(1 - alpha, (rows - 1) * (cols - 1)),
+    '\nP-érték:', pertek,
+    '\nDöntés:', if (pertek < alpha) { 'H0 elutasítva' }
+    else { 'H0-t nem sikerült elvetni' }, '\n')
+\end{verbatim}
+
+\pagebreak
+
+\subsection{Korreláció- és regresszióelemzés}
+
+\subsubsection{Korreláció}
+
+\begin{outline}
+	\1 Korreláció: szimmetrikus, két változó lineáris kapcsolatának erőssége
+	\1 Értéke: -1 és 1 között, ahol -1 az erős negatív kapcsolat
+		\2 Függetlenség esetén az együttható 0 (visszafelé nem igaz)
+	\1 Elméleti korrelációs együttható: $R(X,Y) = \frac{cov(X,Y)}{D(X)D(Y)}
+	= \frac{E((X-E(X))(Y-E(Y)))}{D(X)D(Y)}$
+	\1 Pearson tapasztalati korreláció: $r_{X,Y} =
+	\frac{\sum_{1}^{n}(X_i - \overline{X})(Y_i - \overline{Y})}{(n-1 )S_X S_Y}
+	= \frac{\sum_{1}^{n}(X_i - \overline{X})(Y_i - \overline{Y})}
+	{\sqrt{ \sum (x_i - \overline{X})^2 * \sum (y_i - \overline{Y})^2 }}$
+		\2 R-ben: \texttt{cor(x,y)}\\
+		vagy \texttt{sum((x-mean(x))*(y-mean(y))) / ((length(x)-1)*sd(x)*sd(y))}
+\end{outline}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=0.7\linewidth]{korreláció}
+\end{figure}
+
+\subsubsection{Regresszió}
+
+\begin{outline}
+	\1 Regresszió: két vagy több változó között fennálló kapcsolat modellezése
+		\2 Egyszerű lineáris regresszió: két változó irányított lineáris kapcsolata
+	\1 $y_i = a + bx_i + \epsilon_i$ ahol $y$ függő/eredmény és $x$ magyarázó
+		\2 $E(\epsilon)=0$ és $D^2(\epsilon) = \sigma^2 < \infty$ (normál eloszlás)
+		\2 $X$ legyen hiba nélküli (vagy elhanyagolható hibájú)
+	\1 Bármely jelölésen kalap: konkrét értéket jelent (pl. $\widehat{\epsilon_i} = y_i - \widehat{y_i}$)
+	\1 Legkisebb négyzetek módszer: $\min \sum_{i=1}^{n} ( y_i - (a+bx_i) )^2$
+\pagebreak
+	\1 Reziduális: becsült és valós $y$ függőleges távolsága adott $x$ esetén
+	\1 Hiba szórásnégyzet becslés: $\widehat{\sigma}^2 = \frac{\sum (y_i - \widehat{y_i})^2}{n-2}$
+	\;\; (residual standard error)
+	\1 Determinációs együttható:
+		\2 $0 \le R^2 \le 1$, minél nagyobb, annál jobb a modell
+		\2 Megadja, hogy $Y$ változásainak hány százalék magyarázza a modell
+		\2 Sima: $R^2 = 1 - \frac{\sum(y_i - \widehat{y_i})^2}{\sum(y_i - \overline{y})^2}$
+			\3 Nő, ha több magyarázó változót használunk, tehát nem ideális
+		\2 Korrigált: $R^2_{adj} = 1 - (1-R^2) \frac{n-1}{n-p}$ ahol $p$ a változók száma (itt: 2)
+	\1 R-ben: \texttt{summary(lm(függő $\sim$ magyarázó))} \;\; (két vektor)
+		\2 \texttt{Residuals}: kevés adat esetén az értékek, sok esetén összesítés
+		\2 \texttt{Intercept} sor: $a$ értéke (függőleges eltolás)
+		\2 \texttt{Estimate} oszlop: $a$, $b$ értéke (szorzó)
+		\2 \texttt{Pr(>|t|)} oszlop: mennyire fontos ez a változó a modellbenó
+			\3 $H_0$: lehetne 0, el lehetne hagyni a változót
+			\3 $H_1$: nem 0, azaz fontos a változó
+			\3 \texttt{Pr(>|t|)} $< \alpha = 0.05 \implies$ fontos a változó, $H_0$ elvetve
+		\2 \texttt{Residual standard error}: reziduális szórás becslése, $\sqrt{\widehat{\sigma}^2}$
+		\2 \texttt{Multiple/Adjusted R-squared}: (korrigált) determinációs együttható
+	\1 Hasznos R függvények:
+		\2 Legyen \texttt{reg <- lm(y $\sim$ x)}
+		\2 Ábrázolás: \texttt{plot(x,y); lines(x, reg\$fitted.values)}
+		\2 Kiszámolás adott $x$-re: \texttt{reg\$coefficients[1] + adottX * reg\$coefficients[2]}
+	\1 Manuális "megoldása" $y=a+bx$-nek
+		\2 $\hat{b} = \frac{cov(X,Y)}{D^2(X)}$ \; (R-ben: \texttt{cov(x,y) / sd(x)\^{}2})
+		\2 $D^2(\hat{b}) = \frac{\sigma^2}{\sum(x_i - \overline{X})^2}$
+		\2 $\hat{a} = EY - \hat{b}EX$ \; (R-ben: \texttt{mean(y) - $\hat{b}$*mean(x)})
+		\2 $D^2(\hat{a}) = \sigma^2(\frac{1}{n} + \frac{\overline{X}^2}{\sum(x_i - \overline{X})^2})$
+\end{outline}
+
+\pagebreak
+
+\section{Előadás 12: lineáris modell, logisztikus regresszió, vegyes kapcsolat}
+
+\begin{outline}
+	\1 TODO 12. előadás
+	\1 Remélhetőleg nem lesz benne a ZH-ban: gyakorlaton se néztük
+\end{outline}
+
+\pagebreak
+
+% EA - GYAK elválasztó
+
+\section{R jegyzet}
+
+\subsection{Hasznos R függvények}
+
+\begin{outline}
+	\1 Indexek, ahol \texttt{TRUE} van: \texttt{which(x == max(x))}
+\end{outline}
+
+\subsection{Grafikonok, plot-ok}
+
+\begin{outline}
+	\1 \begin{verbatim}plot( c(...) )\end{verbatim}
+	\1 \begin{verbatim}plot(x, y, type = "l", ...)\end{verbatim}
+	\1 \begin{verbatim}plot(seq(from, to, 0.01), sapply(..., f), ...)\end{verbatim}
+	\1 \begin{verbatim}barplot(f(0:100), names.arg=0:100, ...)\end{verbatim}
+	\1 \begin{verbatim}boxplot(wt ~ cyl, data = mtcars, ...)\end{verbatim}
+		\2 \$out: outlier values
+	\1 \begin{verbatim}hist(x, breaks=5)\end{verbatim}
+		\2 \$counts: gyakoriságok osztályokban
+\end{outline}
+
+\subsection{Matematikai függvények}
+
+\begin{outline}
+	\1 sum(x), sort(x), min(x), max(x), round(x, 4)
+	\1 Mintaátlag, $\overline{X}$: \texttt{mean(x)}
+	\1 Korrigált tapasztalati szórás, $S^*_n$: \texttt{sd(x)}
+	\1 Korrigált szórásnégyzet, $(S^*_n)^2$: \texttt{var(x)}
+	\1 Tapasztalati k-adik momentum, $m_k$: \verb|mean(x^2)|
+	\1 Statisztikák (min, max, átlag, kvartilisek): \texttt{summary(x)}
+	\1 Kvartilis: \texttt{quantile(x, probs = c(1/4, 1/2, 3/4), type = 6)}
+	\1 Tapasztalati eloszlásfüggvény: \texttt{plot(ecdf(x), ...)}
+\end{outline}
+
+\pagebreak
+
+\subsection{Adathalmaz}
+
+\begin{outline}
+	\1 $mtcars$ egy adathalmaz, aminek van $cyl$ és $wt$ oszlopa
+	\1 \begin{verbatim}subset(mtcars, cyl == 4)$wt\end{verbatim}
+	\1 \begin{verbatim}mtcars[mtcars$cyl == 4,]$wt\end{verbatim}
+	\1 Érték-gyakoriság táblázat: \texttt{table(vektor)}
+		\2 Oszlop, ahol <valami> igaz: \texttt{names(tábla)[tábla==max(tábla)] }
+\end{outline}
+
+\subsection{Táblázat, mátrix}
+
+\begin{verbatim}
+ido <- matrix(c(15, 10, 5, 10, 10, 20, 5, 20, 5), ncol=3, byrow=TRUE)
+colnames(ido) <- c("kevés", "átlagos", "sok")
+rownames(ido) <- c("hüvös", "átlagos", "meleg")
+ido <- as.table(ido)\end{verbatim}
+
+\end{document}
diff --git "a/valsz\303\241m-stat/val\303\263sz\303\255n\305\261s\303\251gsz\303\241m\303\255t\303\241s/abszol\303\272t-folytonos-eloszl\303\241sok.png" "b/valsz\303\241m-stat/val\303\263sz\303\255n\305\261s\303\251gsz\303\241m\303\255t\303\241s/abszol\303\272t-folytonos-eloszl\303\241sok.png"
new file mode 100644
index 0000000..086e42f
Binary files /dev/null and "b/valsz\303\241m-stat/val\303\263sz\303\255n\305\261s\303\251gsz\303\241m\303\255t\303\241s/abszol\303\272t-folytonos-eloszl\303\241sok.png" differ
diff --git "a/valsz\303\241m-stat/val\303\263sz\303\255n\305\261s\303\251gsz\303\241m\303\255t\303\241s/diszkr\303\251t-eloszl\303\241sok.png" "b/valsz\303\241m-stat/val\303\263sz\303\255n\305\261s\303\251gsz\303\241m\303\255t\303\241s/diszkr\303\251t-eloszl\303\241sok.png"
new file mode 100644
index 0000000..461cd39
Binary files /dev/null and "b/valsz\303\241m-stat/val\303\263sz\303\255n\305\261s\303\251gsz\303\241m\303\255t\303\241s/diszkr\303\251t-eloszl\303\241sok.png" differ
diff --git "a/valsz\303\241m-stat/val\303\263sz\303\255n\305\261s\303\251gsz\303\241m\303\255t\303\241s/valsz\303\241mstat-val\303\263sz\303\255n\305\261s\303\251gsz\303\241m\303\255t\303\241s.pdf" "b/valsz\303\241m-stat/val\303\263sz\303\255n\305\261s\303\251gsz\303\241m\303\255t\303\241s/valsz\303\241mstat-val\303\263sz\303\255n\305\261s\303\251gsz\303\241m\303\255t\303\241s.pdf"
new file mode 100644
index 0000000..b36c412
Binary files /dev/null and "b/valsz\303\241m-stat/val\303\263sz\303\255n\305\261s\303\251gsz\303\241m\303\255t\303\241s/valsz\303\241mstat-val\303\263sz\303\255n\305\261s\303\251gsz\303\241m\303\255t\303\241s.pdf" differ
diff --git "a/valsz\303\241m-stat/val\303\263sz\303\255n\305\261s\303\251gsz\303\241m\303\255t\303\241s/valsz\303\241mstat-val\303\263sz\303\255n\305\261s\303\251gsz\303\241m\303\255t\303\241s.tex" "b/valsz\303\241m-stat/val\303\263sz\303\255n\305\261s\303\251gsz\303\241m\303\255t\303\241s/valsz\303\241mstat-val\303\263sz\303\255n\305\261s\303\251gsz\303\241m\303\255t\303\241s.tex"
new file mode 100644
index 0000000..84ef390
--- /dev/null
+++ "b/valsz\303\241m-stat/val\303\263sz\303\255n\305\261s\303\251gsz\303\241m\303\255t\303\241s/valsz\303\241mstat-val\303\263sz\303\255n\305\261s\303\251gsz\303\241m\303\255t\303\241s.tex"
@@ -0,0 +1,529 @@
+% !TeX spellcheck = hu_HU
+\documentclass[12pt,a4paper]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{cmap}
+\usepackage[T1]{fontenc}
+\usepackage[magyar]{babel}
+\usepackage{amsmath}
+\usepackage{amsfonts}
+\usepackage{amssymb}
+\usepackage{graphicx}
+
+\usepackage{outlines}
+\usepackage{hyperref}
+
+\hyphenpenalty=10000
+
+\begin{document}
+
+\begin{center}
+	\huge
+	Valószínűségszámítás és statisztika\\
+	\vspace{1mm}
+	\LARGE
+	Valószínűségszámítás témakör jegyzet\\
+	\vspace{5mm}
+	\large
+	Készült Zempléni András előadásai\\
+	és Kovács Ágnes gyakorlatai alapján\\
+	\vspace{5mm}
+	Sárközi Gergő, 2021-22-2. félév\\
+	Nincsen lektorálva!
+\end{center}
+
+\tableofcontents
+
+\pagebreak
+
+\section{Előadás 1: Bevezetés}
+
+\subsection{Alapfogalmak}
+
+\begin{outline}
+	\1 Eseménytér: $\Omega$, összes lehetséges eredmény (elemi események összessége)
+		\2 Elemi esemény: $\omega$, egy lehetséges kimenet
+		\2 $\Omega$ részhalmazai: események
+		\2 Esemény akkor következik be, ha az egyik elemi eseménye bekötvetkezik
+	\1 Esemény: $\Omega$ részhalmaza
+		\2 Speciális események: $\Omega$ (biztos), $\emptyset$ (lehetetlen)
+		\2 Események összessége: $\mathcal{A}$ (halmazrendszer $\Omega$ részhalmazaiból)
+	\1 Műveletek eseményekkel = logikai műveletek = halmazműveletek
+		\2 $A \cup B$: vagy (egyik vagy másik vagy mindkettő)
+		\2 $A \cap B$: és (mindkettő)
+		\2 $\overline{A}$, $A^C$: ellentett, komplementer
+	\1 Tulajdonságok:
+		\2 $A \setminus B = A \cap \overline{B}$
+		\2 De Morgan: $\overline{A \cup B} = \overline{A} \cap \overline{B}$
+		\2 $\overline{\overline{A}} = A$, $\overline{\Omega} = \emptyset$
+\end{outline}
+
+\pagebreak
+
+\subsection{Valószínűség}
+
+\begin{outline}
+	\1 Valószínűség: végtelen próba esetén a relatív gyakoriság
+	\1 $A$ valószínűségének jele: $P(A)$ \; ($P(A) \ge 0$, $P(\Omega) = 1$, $P(\emptyset) = 0$)
+	\1 Tulajdonságok:
+		\2 Egymást kizáró események esetén additív:\\
+		$A \cap B = \emptyset \implies P(A \cup B) = P(A) + P(B)$
+		\2 $P(A \setminus B) = P(A) - P(A \cap B)$
+		\2 $P(A \cup B) = P(A) + P(B) - P(A \cap B)$
+	\1 $A$ és $B$ független, ha $P(A \cap B) = P(A) * P(B)$
+\end{outline}
+
+\subsubsection{Valószínűségi mező}
+
+\begin{outline}
+	\1 Véges valószínűségi mező:
+		\2 $\Omega = \{\omega_1, \omega_2, ..., \omega_n\}$
+		\2 $p_i = P(\omega_i)$
+		\2 $P(A) = P(\bigcup_{\omega_i \in A} \omega_i) = \sum_{\omega_i \in A} p_i$
+	\1 Klasszikus valószínűségi mező:
+		\2 $p_i = \frac{1}{n}$ (azonos valószínűségű elemi események)
+		\2 $P(A) = \frac{k}{n}$ ahol $k$ az $A$ eseményszáma
+		\2 Azaz $P(A) = \frac{\text{Kedvező esetek száma}}{\text{Összes eset száma}}$
+\end{outline}
+
+\subsubsection{Mintavétel}
+
+\begin{outline}
+	\1 $N$ termékből $M$ selejtes, $n$ elemű a minta
+	\1 $A$: pontosan $k$ selejtes van a mintában
+	\1 Visszatevéses mintavétel:
+		\2 $P(A) = {n \choose k} (\frac{M}{N})^k (1 - \frac{M}{N})^{n-k}$
+		\2 Ha $p=\frac{M}{N}$: $P(A) = {n \choose k} p^k (1 - p)^{n-k}$
+	\1 Visszatevés nélküli mintavétel:
+		\2 $P(A) = {M \choose k} {N - M \choose n - k} \; / \; {N \choose n}$
+\end{outline}
+
+\pagebreak
+
+\subsubsection{Feltételes valószínűség}
+
+\begin{outline}
+	\1 $A$ esemény valószínűségét keressük; tudjuk, hogy $B$ bekövetkezett
+	\1 Relatív gyakorisággal: $r_{A \cap B} \; / \; r_B$
+	\1 $P(A|B) = \frac{P(A \cap B)}{P(B)}$ ahol $P(B) > 0$
+	\1 $P(A|B)P(B) = P(A,B)$ \;\;($A$ és $B$)
+\end{outline}
+
+\subsubsection{Teljes eseményrendszer; tételek}
+
+\begin{outline}
+	\1 Teljes eseményrendszer: események halmaza, melyek egymást páronként kizárják és egyesítésük $\Omega$.
+		\2 $P(A_1) + P(A_2) + ... = 1$
+	\1 Teljes valószínűség tétele:
+		\2 Legyen pozitív valószínűségű $B_1,B_2,...$ teljes eseményrendszer
+		\2 Legyen $A$ tetszőleges esemény
+		\2 Ekkor $P(A) = P(A|B_1)P(B_1) + P(A|B_2)P(B_2)+...$
+	\1 Bayes tétel:
+		\2 Legyen pozitív valószínűségű $B_1,B_2,...$ teljes eseményrendszer
+		\2 Legyen $A$ tetszőleges pozitív valószínűségű esemény
+		\2 $P(B_k|A) = \frac{P(A|B_k)P(B_k)}{\sum P(A|B_i)P(B_i)} = \text{(magyarázat)} = \frac{P(A \cap B_k)}{P(A)}$
+		\2 Komplementerrel: $P(B|A) = \frac{P(A|B)P(B)}{P(A|B)P(B) + P(A|\overline{B})P(\overline{B})}$
+\end{outline}
+
+\subsection{Permutáció, variáció, kombináció}
+
+\begin{outline}
+	\1 Permutáció: $n$ elem lehetséges sorrendje
+	\1 Kombináció (sorrend nem számít) és variáció (sorrend számít):\\
+	$n$ elemből $k$ kiválasztása
+\end{outline}
+
+\begin{table}[h!]
+	\centering
+	\begin{tabular}{|c|c|c|c|}
+		\hline
+		- & Permutáció & Kombináció & Variáció \\
+		\hline
+		Ismétlés nélkül & $n!$ & ${n \choose k} = \frac{n!}{k!(n-k)!}$ & $\frac{n!}{(n-k)!}$ \\
+		\hline
+		Ismétléssel & \vtop{\hbox{\strut $k_i$ db egyezik:}\hbox{\strut $\frac{n!}{k_1!*...*k_r!}$}} & ${n + k -1 \choose k}$ & $n^k$ \\
+		\hline
+	\end{tabular}
+\end{table}
+
+\pagebreak
+
+\section{Előadás 2, 3: valószínűségi változók, eloszlások}
+
+\subsection{Események függetlensége}
+
+\begin{outline}
+	\1 Nem összekeverni az egymást kizáró eseményekkel!
+	\1 $A$ és $B$ események függetlenek, ha $P(A \cap B) = P(A)*P(B)$
+	\1 Ha $A$ és $B$ függetlenek, akkor komplementereik is függetlenek
+	\1 Ha $A$ és $B$ diszjunktak, akkor csak triviális esetben függetlenek (P=0)
+	\1 Önmaguktól csak triviális események függetlenek
+	\1 Több páronkénti függetlenségből nem következik összevont függetlenség
+	\1 $A \subset B \implies$ csak akkor függetlenek, ha legalább az egyik triviális
+	\1 Példa függetlenségre: $A$ az első, $B$ a második kísérlet eredménye
+\end{outline}
+
+\subsection{Valószínűségi változók}
+
+\begin{outline}
+	\1 Számot rendel egy kísérlet eredményéhez (elemi eseményhez)
+	\1 $X:\Omega \to \mathbb{R}$ függvény, hogy $\forall a: \{\omega | X(\omega) < a\} \in \mathcal{A}$
+	\1 Eloszlásfüggvény: $F_X(x) = P(X < x)$
+		\2 monoton növekvő, balról folytonos
+		\2 $\lim\limits_{x \to -\infty} F_X(x) = 0$ és $\lim\limits_{x \to +\infty} F_X(x)=1$ \;\; (tehát $0 \le F_X(x) \le 1$)
+	\1 $P(a \le X < b) = F_X(b) - F_X(a)$\\
+	$P(a < X \le b) = F_X(b+0) - F_X(a+0)$%\\
+	%$P(a < X < b) = F_X(b) - F_X(a+0)$\\
+	%$P(a \le X \le b) = F_X(b+0) - F_X(a)$
+	\1 Indikátorváltozó eloszlásfüggvénye: $F_X(x) = \begin{cases}
+		0, &\text{ha } x \le 0\\
+		1-p, &\text{ha } 0 < x \le 1\\
+		1, &\text{ha } 1 < x\\
+	\end{cases}$
+	\1 $X$ folytonos eloszlású, ha eloszlásfüggvénye folytonos, pl:\\
+	Egyenletes eloszlás $[a,b]$ intervallumon: $F_X(x) = \begin{cases}
+		0, &\text{ha } x \le a\\
+		\frac{x-a}{b-a}, &\text{ha } a < x \le b\\
+		1, &\text{ha } b < x\\
+	\end{cases}$
+	\1 Exponenciális eloszlás ($\lambda$ paraméter): $F_X(x) = \begin{cases}
+		0, &\text{ha } x \le 0\\
+		1-e^{-\lambda x}, &\text{ha } 0 < x
+	\end{cases}$
+\end{outline}
+
+\pagebreak
+
+\subsubsection{Várható érték, szórás}
+
+\begin{outline}
+	\1 Legyen $X:\Omega \to \mathbb{R}$ valószínűségi változó
+	\1 Várható érték (mean): $E(X)=EX=\int_\Omega XdP$
+	\1 Szórásnégyzet (variance): $D^2(X) = E[(X-EX)]^2=E(X^2)-E^2(X)$
+		\2 Átrendezve: $E(X^2) = D^2(X) + E^2(X)$
+	\1 Szórás (standard deviation, $\sigma$): $D(X)=\sqrt{D^2(X)}$
+	\1 Várható érték lehet végtelen:\\
+	$P(X=2^k)=(1/2)^k \implies E(X)=1+1+1+...=\infty$
+	\1 Legyen $E(X)$ és $E(Y)$ véges és $a,b \in \mathbb{R}$
+		\2 Ekkor $E(aX+b) = aEX+b$
+		\2 Ekkor $E(X+Y) = EX+EY$
+	\1 $X \ge 0$ és $E(X)$ véges $\implies E(X) \ge 0$
+	\1 $D^2(aX+b) = a^2D^2(X)$ \;\; (Tehát $D(aX) = |a|D(X)$)
+	\1 $D^2(X+Y) = D^2(X)+D^2(Y)+2cov(X,Y)$
+	\1 Ha $X$ nemnegatív egész értékű: $E(X) = P(X\ge1) + P(X\ge2) + ...$
+		\2 pl. dobókocka: $E(X)=3.5=\frac{6}{6}+\frac{5}{6}+\frac{4}{6}+\frac{3}{6}+\frac{2}{6}+\frac{1}{6}$
+	\1 Attól még, hogy $E(X)$ véges, $D^2(X)$ nem feltétlenül véges:\\
+	pl.: $P(X=k)=c/k^3$ ha eloszlás, attól még $E(X^2)=c(1/1+1/2+...)$
+	\1 $X$, $Y$ függetlenek $\implies E(XY)=E(X)E(Y)$
+	\1 $Z$: $p$ valószínűséggel $X$, $1-p$ valószínűséggel $Y$:\\
+	$E(Z) = p*E(X) + (1-p)*E(Y)$
+\end{outline}
+
+\subsubsection{Valószínűségi változó: egyebek}
+
+\begin{outline}
+	\1 Vektor valószínűségi változó: ha $\underline{X}$ koordinátái függetlenek:\\
+	$F_{\underline{X}}(\underline{z}) = P(X_1 < z_1, X_2 < z_2, ...) = F_1(z_1)F_2(z_2)...$
+	\1 $iid$ ($i.i.d.$) jelentése: független és azonos eloszlású
+\end{outline}
+
+\pagebreak
+
+\subsection{Diszkrét valószínűségi változók}
+
+\begin{outline}
+	\1 Értékkészlet véges vagy megszámlálhatóan végtelen
+		\2 Véges, vagy megszámlálhatóan végtelen valószínűségi mezőn minden valószínűségi változó diszkrét
+	\1 Legyen $X=(x_1,...,x_n)$, ekkor $p_i = P(X = x_i)$ és $\sum_{i=1}^{n} P(X=x_i) = 1$
+	\1 Elfajult eloszlás: $\forall \omega: X(\omega) = c$,\; $P(X=c)=1$
+	\1 Ha $X$ diszkrét valószínűségi változó: $\{\omega | X(\omega)=x_i\}$ teljes eseményrendszer
+	\1 $X+Y$, mint diszkrét valószínűségi változó
+		\2 $P(X+Y=z)=\sum_y P(X=z-y,\; Y=y)$
+		\2 Ha $X$ és $Y$ függetlenek:\\
+		$P(X+Y=z) = \sum_{x_i+y_j=z} P(X=x_i)P(Y=y_j)$
+\end{outline}
+
+\subsubsection{Valószínűségi változók függetlensége}
+
+\begin{outline}
+	\1 $X$ és $Y$ függetlenek, ha $\forall i,k:$\\
+	$P(\{X=x_i\} \cap \{Y = Y_k\}) = P(X=x_i)*P(Y=y_k)$
+		\2 (Azaz, ha $X$-hez és $Y$-hoz tartozó teljes eseményrendszerek függetlenek)
+	\1 Elfajult eloszlású valószínűségi változó miden val. változótól független
+	\1 Önmagától csak az elfajult eloszlású valószínűségi változó független
+\end{outline}
+
+\subsubsection{Várható érték, szórás}
+
+\begin{outline}
+	\1 $E(X)=\sum x_k P(X=x_k)$ ha a végtelen összeg abszolút konvergens
+		\2 $E(X^2)$: az $x_k$ értéket négyzetre kell emelni
+		\2 Dobókocka: $E(X)= \frac{1}{6}*\sum_{i=1}^{6} i = 3.5$\\
+		És a szórásnégyzet: $D^2(X)=91/6 - 3.5^2 = 105/36$
+	\1 Elfajult eloszlás várható értéke: $E(X)=cP(X=c)=c$
+	\1 Egyenletes eloszlás várható értéke: számok számtani közepe
+	\1 Függvény várható értéke: $E(g(x)) = \sum P(X=x_i) g(x_i)$
+\end{outline}
+
+\pagebreak
+
+\subsubsection{Nevezetes diszkrét eloszlások}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=1\linewidth]{diszkrét-eloszlások}
+\end{figure}
+
+\begin{outline}
+	\1 Indikátor: $p$ valószínűségű esemény bekövetkezik-e vagy sem
+	\1 Binomiális: visszatevéses mintavétel
+	\1 Poisson: időben lejátszódó folyamatnál adott $[a,b)$ intervallumba eső események száma ($X_{a,b}$) éppen $\lambda(b-a)$ paraméterű Poisson eloszlású
+		\2 ha homogén az esemény: $\lambda$ nem változik az idővel
+		\2 ha utóhatás nélküli az esemény: a<b<c $\implies X_{a,b}$ és $X_{b,c}$ függetlenek
+		\2 nemelfajuló: $0 < P(X_{a,b}=0) < 1$
+	\1 Geometriai (Pascal): hányadikra következik be először egy $p$ valószínűségű
+	\1 Negatív binomiális: hányadikra következik be $n$. alkalommal egy $p$ valószínűségű esemény
+	\1 Hipergeometriai: visszatevés nélküli mintavétel
+\end{outline}
+
+\subsection{Gyakorlat}
+
+\begin{outline}
+	\1 Diszkrét eloszlást a $P(X=...)=...$ értékekkel adhatjuk meg
+\end{outline}
+
+\pagebreak
+
+\section{Előadás 3: kovariancia, korreláció}
+
+\subsection{Kovariancia}
+
+\begin{outline}
+	\1 $cov(X,Y) = E(\; (X-E(X))*(Y-E(Y)) \;) =$\\
+	$=E(\; XY - XE(Y) - YE(X) - E(X)E(Y) \;) =$\\
+	$=E(XY) - E(X)E(Y)$
+	\1 $X,Y$ függetlenek $\implies cov(X,Y) = 0$ \;\; (Visszafelé nem igaz)
+	\1 Szimmetrikus: $cov(X,Y)=cov(Y,X)$
+	\1 Kapcsolat szórásnégyzethez: $cov(X,X) = D^2(X)$
+	\1 Skálafüggő: $cov(a*X, b*Y) = ab*cov(X,Y)$
+\end{outline}
+
+\subsection{Korrelációs együttható}
+
+\begin{outline}
+	\1 Változók közötti lineáris kapcsolat erősségét méri:\\
+	$R^2 \approx 1$ az erős kapcsolatot, $R^2 \approx 0$ a gyenge kapcsolatot jelenti
+	\1 $R(X,Y) = \frac{cov(X,Y)}{D(X)D(Y)}$
+	\1 $X,Y$ függetlenek $\implies R(X,Y) = 0$ \;\; (Visszafelé nem igaz)
+	\1 $X$ vagy $Y$ elfajult $\implies R(X,Y)=0$
+	\1 $R(X,aX+b) = 1$ ha $a>0$
+\end{outline}
+
+\pagebreak
+
+\section{Előadás 4: abszolút folytonos eloszlások}
+
+\begin{outline}
+	\1 Sűrűségfüggvény eloszlásfüggvényből
+		\2 Legyen $F$ eloszlásfüggvény és létezzen $f$, hogy $F(z) = \int_{-\infty}^{z}f(t)dt$
+		\2 Ekkor $f$ sűrűségfüggvény és $F$ abszolút folytonos
+		\2 $f$ nem egyértelmű $\implies$ legegyszerűbb szakaszonként folytonos változatát vesszük
+	\1 Eloszlásfüggvény sűrűségfüggvényből: (fentieken túl)
+		\2 Ha $X \ge 0$, akkor $F(0)=0$ (ebből integrálás konstans szerezhető)
+	\1 $P(a < X \le b) = P(a \le X < b) = F(b) - F(a)$
+	\1 Várható érték: $E(X) = \int_{-\infty}^{+\infty}xf(x)dx$ (ha az integrál létezik)
+		\2 Függvény várható értéke: $E(g(x)) = \int_{-\infty}^{+\infty}g(x)f(x)dx$
+\end{outline}
+
+\subsection{Sűrűségfüggvény}
+
+\begin{outline}
+	\1 Legyen $X$ abszolút folytonos eloszlású
+	\1 $f(x) = F'(x)$ (esetleg néhány pont kivételével)
+	\1 $f(x) \ge 0$ és $\int_{-\infty}^{+\infty}f(x)dx = 1$
+		\2 Megengedett: $\exists x: f(x) > 1$
+	\1 $F$ folytonos, tehát $\forall x: P(X=x) = 0$
+\end{outline}
+
+\subsection{Standard normális eloszlás}
+
+\begin{outline}
+	\1 Sűrűségfüggvény: $f(x) = \frac{1}{\sqrt{2\pi}} e^{-x^2/2}$
+		\2 Haranggörbe, csúcs $x=0$-ban
+	\1 Normális eloszlás standardizálása:
+		\2 Legyen $X \sim N(m, \sigma^2)$
+		\2 Ekkor $\frac{X-m}{\sigma} \sim N(0,1)$
+\end{outline}
+
+\pagebreak
+
+\subsection{Nevezetes abszolút folytonos eloszlások}
+
+\begin{figure}[h!]
+	\centering
+	\includegraphics[width=1\linewidth]{abszolút-folytonos-eloszlások}
+\end{figure}
+
+\begin{outline}
+	\1 A "geometriai modell" az egyenletes eloszlást jelent
+	\1 Chi-négyzet eloszlás ($Ki^2$): $X \sim \chi^2_n$ ha $X = \sum Z_i$ ahol $Z_i \sim N(0,1)$
+	\1 $t$ eloszlás: $X \sim t_n$ ha $X=\frac{Z}{\sqrt{Y_n/n}}$ ahol $Z \sim N(0,1)$ és $Y_n \sim \chi^2_n$
+	\1 $F$ eloszlás: $X \sim F_{n_1,n_2}$ ha $X=\frac{U_1/n_1}{U_2/n_2}$ ahol $U_i \sim \chi^2_{n_i}$
+\end{outline}
+
+\subsection{Függvény eloszlása}
+
+\begin{outline}
+	\1 $X$ egy valószínűségi változó $\implies$ $g(X)$ is az
+	\1 $X$ folytonosságából NEM következik $g(X)$ folytonossága
+	\1 Legyen $X$ abszolút folytonos
+	\1 Legyen $g : \mathbb{R} \to \mathbb{R}$, folytonosan differenciálható, $g' \ne 0$
+	\1 $Y=g(x)$ eloszlásfüggvénye:\\
+	$F_Y(y) = F_{g(x)}(y) = \begin{cases}
+	F_X(g^{-1}(y)) & \text{ha $g$ szig. mon. nő}\\
+	1 - F_X(g^{-1}(y)) & \text{ha $g$ szig. mon. csökken}
+	\end{cases}$
+		\2 Példa: $F_{aX+b} = F_X((z-b)/a)$ ha $a > 0$
+		\2 Példa: $F_{aX+b} = 1 - F_X((z-b)/a)$ ha $a < 0$
+	\1 $Y=g(X)$ sűrűségfüggvénye:\\
+	$f_Y(y) = f_{g(x)}(y) = F_X(g^{-1}(y)) * |(g^{-1}(y))'| = f_X(g^{-1}(y)) \;/\; |g'(g^{-1}(y))|$\\
+	Lényeg: $f_{g(x)}(y) = f_X(g^{-1}(y)) \;/\; |g'(g^{-1}(y))|$
+\end{outline}
+
+\pagebreak
+
+\subsection{Együttes eloszlásfüggvények elnevezései}
+
+\begin{outline}
+	\1 Együttes eloszlásfüggvény: $F_{X,Y}(x,y) = P(X < x, Y < y)$
+	\1 Peremeloszlásfüggvények: $F_X(x) = P(X < x)$, $F_Y(y) = P(Y < y)$
+	\1 Együttes sűrűségfüggvény: $f_{X,Y}(x,y)$
+	\1 Peremsűrűségfüggvények: $f_X(x)$, $f_Y(y)$
+\end{outline}
+
+\subsection{Együttes eloszlásfüggvények kapcsolata}
+
+\begin{outline}
+	\1 $F_X(x) = \lim\limits_{y \to \infty} F_{X,Y}(x,y)$
+	\1 $F_{X,Y}(x,y) = \int_{-\infty}^{y} \int_{-\infty}^{x} f_{X,Y}(u,v) dudv$
+	\1 $f_{X,Y}(x,y) = \partial_y \partial_x F_{X,Y}(x,y) = \partial_x \partial_y F_{X,Y}(x,y)$
+	\1 $\int_{-\infty}^{+\infty} \int_{-\infty}^{+\infty} f_{X,Y}(x,y) dxdy = 1$
+	\1 $F_X(x) = \int_{-\infty}^{+\infty} f_{X,Y}(x,y)dy$
+	\1 $X,Y$ függetlenek $\Leftrightarrow$ $F_{X,Y}(x,y) = F_X(x)*F_Y(y)$
+	\1 $X,Y$ függetlenek $\Leftrightarrow$ $f_{X,Y}(x,y) = f_X(x)*f_Y(y)$
+	\1 Diszkrét esetben:\\
+	$X,Y$ függetlenek $\Leftrightarrow$ $P(X = x, Y = y) = P(X = x) * P(Y = y)$
+	\1 $X,Y$ függetlenek $\Leftrightarrow$ $E(XY) = E(X) * E(Y)$
+\end{outline}
+
+\section{Előadás 5: máshová írtam be az anyagot}
+
+\pagebreak
+
+\section{Előadás 6: egyenlőtlenségek, aszimptotikus tulajdonságok}
+
+\subsection{Markov-típusú egyenlőtlenségek}
+
+\begin{outline}
+	\1 Legyen $X \ge 0$ val. változó, legyen $g : \mathbb{R}_+ \to \mathbb{R}_+$ monoton növő
+	\1 Ekkor $\epsilon > 0$ esetén $P(X \ge \epsilon) \le \frac{E(g(X))}{g(\epsilon)}$
+	\1 Bizonyítás: $E(g(X)) \ge g(\epsilon)P(X \ge \epsilon)$ mert $X \ge \epsilon \implies g(X) \ge g(\epsilon)$
+\end{outline}
+
+\subsubsection{Alkalmazásai}
+
+\begin{outline}
+	\1 Gyakorlatban nem kellően pontos becslést adnak, konkrét eloszlás ismeretével pontosabb becslés szerezhető
+	\1 Markov egyenlőtlenség:
+		\2 $g(x)=x$ és $X \ge 0$ val. változó esete, ekkor $P(X \ge \epsilon) \le \frac{E(X)}{\epsilon}$
+		\2 Máshogy: $P(X \ge k*E(X)) \le \frac{E(X)}{k*E(X)} = \frac{1}{k}$
+	\1 Csebisev egyenlőtlenség:
+		\2 $g(x)=x$ és $X$ helyett $(X-EX)^2$ esete
+		\2 $P((X-EX)^2 \ge \epsilon^2) \le \frac{E(X-EX)^2}{\epsilon^2} \; \implies \;$
+		$P(|X-EX| \ge \epsilon) \le \frac{D^2(X)}{\epsilon^2}$
+\end{outline}
+
+\subsection{Konvergencia típusai}
+
+\begin{outline}
+	\1 Legyen $X_i$ val. változók sorozata, ekkor $X_n \to (n \to +\infty) \to X$...
+	\1 ... 1 valószínűséggel: $P(\{ \omega \;:\; X_n(\omega) \to (n \to +\infty) \to X(\omega) \}) = 1$
+	\1 ... gyengén: ha eloszlásfüggvényeikre $F_n(x) \to (n \to +\infty) F(x)$
+		\2 $F$ minden folytonossági pontjában
+\end{outline}
+
+\subsection{Nagy számok törvényei}
+
+\begin{outline}
+	\1 Legyen $X_1, X_2, ..., X_n$ független, azonos eloszlású valószínűségi változók
+	\1 Legyen a várható értékük (ami azonos, hiszen azonos az eloszlás) véges
+	\1 $\frac{X_1 + ... + X_n}{n} \to m = E(X_i) = E(X_1)$ ha $n \to +\infty$
+	\;\; (1 valószínűséggel)
+\end{outline}
+
+\pagebreak
+
+\subsection{Centrális határelosztás tétel}
+
+\begin{outline}
+	\1 Legyen $X_1, X_2, ..., X_n$ független, azonos eloszlású valószínűségi változók
+	\1 Legyen a szórásnégyzetük ($\sigma^2 = D^2(X_i)$) véges
+		\2 Nulla sem lehet, nem? Hiszen osztunk vele
+	\1 Szórásuk, várható értékük ($m=E(X_i)$) egyezik, mert azonos az eloszlásuk
+	\1 $\frac{X_1 + ... + X_n - n*m}{\sqrt{n} * \sigma} \to N(0,1)$ ha $n \to +\infty$
+	\;\; (gyengén)
+		\2 Máshogy: $P(\frac{X_1 + ... + X_n - n*m}{\sqrt{n} * \sigma} < x) \to \Phi(x)$
+		\2 Máshogy: $n$ kísérlet összegének szórása $\frac{1}{\sqrt{n}}$-nel arányos
+	\1 Legyen $\overline{X}$ átlag: $\overline{X} = \frac{X_1 + ... X_n}{n}$,
+	ekkor $\overline{X} \sim N(\mu, (\frac{\sigma}{\sqrt{n}})^2)$ \;\; ($E(X_i) = \mu$)
+	\1 Felhasználás: $0.9$ valószínűséggel legyen $X < 99.5$ ahol $X \sim N(100, 3^2)$
+		\2 $\overline{X} \sim N(100, (\frac{3}{\sqrt{n}})^2)$ a tétel szerint
+		\2 Legyen $S$ std normál: $S \sim N(0,1)$
+		\2 $0.9 = P(\overline{X} < 99.5) = P(S < \frac{99.5-100}{3/\sqrt{n}}) = \Phi(\frac{99.5-100}{3/\sqrt{n}})$
+		\2 Megoldás: $0.9 = \Phi(\frac{99.5-100}{3/\sqrt{n}}) = \Phi(\frac{\sqrt{n}}{-6}) = \Phi(\frac{\sqrt{n}}{6})$\\
+		$n=(qnorm(0.9) * 6)^2 \approx 59.12$
+\end{outline}
+
+\pagebreak
+
+\section{R jegyzet}
+
+\begin{outline}
+	\1 choose(x, y); \verb|cat("X:", x, "\n", "valami"))|; round(x, 4)
+	\1 diszkrét
+		\2 ppois, pbinom, phyper
+		\2 sum(dbinom(0:4, 12, 0.2)) = pbinom(4, 12, 0.2)
+		\2 \begin{verbatim}
+		barplot(dbinom(0:6, 6, 527/1000),
+		        col="red",
+		        xlab="k értéke",
+		        ylab="Valószínűség",
+		        main="Binomiális eloszlás",
+		        names.arg = 0:6)
+		\end{verbatim}
+	\1 abszolút folytonos
+		\2 pnorm
+		\2 d\{dist\}(a, ...) = f(a)
+		\2 p\{dist\}(a, ...) = F(X < a)
+		\2 q\{dist\}(p, ...) = a $\implies$ F(X < a) = p
+		\2 \begin{verbatim}
+		valx <- seq(90, 110, 0.01)
+		valy <- pnorm(valx, 100, 2)
+		plot(valx, valy, col = "red", type = "l", lwd = 2,
+		     xlab = "x", ylab = "Fi(x)",
+		     main = "Eloszlásfüggvény")
+		abline(h = c(0, 1), lty = 2)
+		\end{verbatim}
+	\1 plot-olás
+		\2 lwd: line width (2-3 szokott lenni)
+		\2 lty: line type, (1=folytonos, 2=dashed, 3=dotted, ...)
+		\2 \begin{verbatim}
+		my_plot <- function(f, from_x, to_x) {
+		  x <- seq(from_x, to_x, 1 / 100)
+		  y <- sapply(x, f)
+		  plot(x, y, type = "l", col = "black", lwd = 3)
+		  abline(h = c(0, 1))
+		}
+		\end{verbatim}
+\end{outline}
+
+\end{document}