diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..f148e73 --- /dev/null +++ b/.gitignore @@ -0,0 +1,291 @@ +__latexindent_temp.* + +## Core latex/pdflatex auxiliary files: +*.aux +*.lof +*.log +*.lot +*.fls +*.out +*.toc +*.fmt +*.fot +*.cb +*.cb2 +.*.lb + +## Intermediate documents: +*.dvi +*.xdv +*-converted-to.* +# these rules might exclude image files for figures etc. +# *.ps +# *.eps +# *.pdf + +## Generated if empty string is given at "Please type another file name for output:" +.pdf + +## Bibliography auxiliary files (bibtex/biblatex/biber): +*.bbl +*.bcf +*.blg +*-blx.aux +*-blx.bib +*.run.xml + +## Build tool auxiliary files: +*.fdb_latexmk +*.synctex +*.synctex(busy) +*.synctex.gz +*.synctex.gz(busy) +*.pdfsync + +## Build tool directories for auxiliary files +# latexrun +latex.out/ + +## Auxiliary and intermediate files from other packages: +# algorithms +*.alg +*.loa + +# achemso +acs-*.bib + +# amsthm +*.thm + +# beamer +*.nav +*.pre +*.snm +*.vrb + +# changes +*.soc + +# comment +*.cut + +# cprotect +*.cpt + +# elsarticle (documentclass of Elsevier journals) +*.spl + +# endnotes +*.ent + +# fixme +*.lox + +# feynmf/feynmp +*.mf +*.mp +*.t[1-9] +*.t[1-9][0-9] +*.tfm + +#(r)(e)ledmac/(r)(e)ledpar +*.end +*.?end +*.[1-9] +*.[1-9][0-9] +*.[1-9][0-9][0-9] +*.[1-9]R +*.[1-9][0-9]R +*.[1-9][0-9][0-9]R +*.eledsec[1-9] +*.eledsec[1-9]R +*.eledsec[1-9][0-9] +*.eledsec[1-9][0-9]R +*.eledsec[1-9][0-9][0-9] +*.eledsec[1-9][0-9][0-9]R + +# glossaries +*.acn +*.acr +*.glg +*.glo +*.gls +*.glsdefs +*.lzo +*.lzs + +# uncomment this for glossaries-extra (will ignore makeindex's style files!) +# *.ist + +# gnuplottex +*-gnuplottex-* + +# gregoriotex +*.gaux +*.glog +*.gtex + +# htlatex +*.4ct +*.4tc +*.idv +*.lg +*.trc +*.xref + +# hyperref +*.brf + +# knitr +*-concordance.tex +# TODO Uncomment the next line if you use knitr and want to ignore its generated tikz files +*.tikz +*-tikzDictionary + +# listings +*.lol + +# luatexja-ruby +*.ltjruby + +# makeidx +*.idx +*.ilg +*.ind +*.ist + +# minitoc +*.maf +*.mlf +*.mlt +*.mtc[0-9]* +*.slf[0-9]* +*.slt[0-9]* +*.stc[0-9]* + +# minted +_minted* +*.pyg + +# morewrites +*.mw + +# newpax +*.newpax + +# nomencl +*.nlg +*.nlo +*.nls + +# pax +*.pax + +# pdfpcnotes +*.pdfpc + +# sagetex +*.sagetex.sage +*.sagetex.py +*.sagetex.scmd + +# scrwfile +*.wrt + +# sympy +*.sout +*.sympy +sympy-plots-for-*.tex/ + +# pdfcomment +*.upa +*.upb + +# pythontex +*.pytxcode +pythontex-files-*/ + +# tcolorbox +*.listing + +# thmtools +*.loe + +# TikZ & PGF +*.dpth +*.md5 +*.auxlock + +# todonotes +*.tdo + +# vhistory +*.hst +*.ver + +# easy-todo +*.lod + +# xcolor +*.xcp + +# xmpincl +*.xmpi + +# xindy +*.xdy + +# xypic precompiled matrices and outlines +*.xyc +*.xyd + +# endfloat +*.ttt +*.fff + +# Latexian +TSWLatexianTemp* + +## Editors: +# WinEdt +*.bak +*.sav + +# Texpad +.texpadtmp + +# LyX +*.lyx~ + +# Kile +*.backup + +# gummi +.*.swp + +# KBibTeX +*~[0-9]* + +# TeXnicCenter +*.tps + +# auto folder when using emacs and auctex +./auto/* +*.el + +# expex forward references with \gathertags +*-tags.tex + +# standalone packages +*.sta + +# Makeindex log files +*.lpz + +# xwatermark package +*.xwm + +# REVTeX puts footnotes in the bibliography by default, unless the nofootinbib +# option is specified. Footnotes are the stored in a file with suffix Notes.bib. +# Uncomment the next line to have this generated file ignored. +#*Notes.bib \ No newline at end of file diff --git a/.vscode/extensions.json b/.vscode/extensions.json new file mode 100644 index 0000000..ed56515 --- /dev/null +++ b/.vscode/extensions.json @@ -0,0 +1,9 @@ +{ + "recommendations": [ + "james-yu.latex-workshop", + "torn4dom4n.latex-support", + "tecosaur.latex-utilities", + "nickfode.latex-formatter", + "coenraads.bracket-pair-colorizer-2" + ] +} diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..207b9df --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,11 @@ +{ + "files.autoSave": "afterDelay", + "editor.tabSize": 4, + "editor.insertSpaces": true, + "latex-workshop.view.pdf.viewer": "tab", + "latex-workshop.latex.autoClean.run": "onBuilt", + "latex-workshop.latex.autoBuild.run": "onSave", + "[latex]": { + "editor.defaultFormatter": "James-Yu.latex-workshop" + }, +} diff --git a/1. Függvények határértéke, folytonossága/1. Függvények határértéke, folytonossága.pdf b/1. Függvények határértéke, folytonossága/1. Függvények határértéke, folytonossága.pdf new file mode 100644 index 0000000..9709525 Binary files /dev/null and b/1. Függvények határértéke, folytonossága/1. Függvények határértéke, folytonossága.pdf differ diff --git a/1. Függvények határértéke, folytonossága/1. Függvények határértéke, folytonossága.tex b/1. Függvények határértéke, folytonossága/1. Függvények határértéke, folytonossága.tex new file mode 100644 index 0000000..d20a32b --- /dev/null +++ b/1. Függvények határértéke, folytonossága/1. Függvények határértéke, folytonossága.tex @@ -0,0 +1,165 @@ +\documentclass[margin=0px]{article} + +\usepackage{listings} +\usepackage[utf8]{inputenc} +\usepackage{graphicx} +\usepackage{float} +\usepackage[a4paper, margin=0.7in]{geometry} +\usepackage{amsthm} +\usepackage{amssymb} +\usepackage{amsmath} +\usepackage{fancyhdr} +\usepackage{setspace} + +\onehalfspacing + +\newenvironment{tetel}[1]{\paragraph{#1 \\}}{} + +\pagestyle{fancy} +\lhead{\it{PTI BSc Záróvizsga tételek}} +\rhead{1. Függvények határértéke, folytonossága} + +\title{\textbf{{\Large ELTE IK - Programtervező Informatikus BSc} \vspace{0.2cm} \\ {\huge Záróvizsga tételek}} \vspace{0.3cm} \\ 1. Függvények határértéke, folytonossága} +\author{} +\date{} + +\begin{document} +\maketitle + +\begin{tetel}{Függvények határértéke, folytonossága} + Függvények határértéke, folytonossága. Kompakt halmazon folytonos függvények tulajdonságai: Weierstrass-tétel, Bolzano-tétel. A hatványsor fogalma, Cauchy-Hadamard-tétel, analitikus függvények. +\end{tetel} + +\section{Függvények határértéke} + +Adott $f \in \mathbb{K}_{1} \to \mathbb{K}_{2}, a \in \mathcal{D}'_{f}$ (torlódási pont). Az $f$ függvénynek az $a$ helyen van határértéke, ha $\exists A \in \overline{\mathbb{K}}_{2}$, ahol $\overline{\mathbb{K}} = \mathbb{C} \vee \mathbb{R} \vee +\infty \vee -\infty$, amelyre tetszőleges $K(A) \subset \mathbb{K}_{2}$ környezetet is véve megadható az $a$-nak egy alkalmas $k(a) \subset \mathbb{K}_{1}$ környezete, amellyel $f[(k(a) \backslash \{a\}) \cap \mathcal{D}_{f}] \subset K(A)$ teljesül. \\ +Másképp: $f(x) \in K(A), (a \neq x \in k(a) \cap \mathcal{D}_{f})$. \\ +Ekkor az egyértelműen létező $A \in \overline{\mathbb{K}}_{2}$ számot vagy valamelyik végtelent az $f$ függvény $a$ helyen vett határértékének nevezzük. \\ +Jelölés: $\lim\limits_{x \to a}{f(x)} = \lim\limits_{a}{f} = A$ + +\subsection{Torlódási pont} + +$A \subset \mathbb{K}$, ekkor az $\alpha \in \overline{\mathbb{K}}$ torlódási pontja az $A$ halmaznak, ha bármely $K(\alpha)$ környezetre $(K(\alpha) \backslash \{\alpha\}) \cap A \neq \emptyset$. \\ +Egyenlőtlenségekkel: $A \subset \mathbb{K}$, ekkor $\alpha \in \mathbb{K}$ szám torlódási pontja az $A$ halmaznak, ha $\forall \varepsilon > 0$ esetén $\exists x \in A$, hogy $0 < |x-\alpha| < \varepsilon$. + +\subsection{Környezet} + +$A \subset \mathbb{K}, a \in A, r > 0: K_{r}(a) = K(a) = \{x \in A: |x-a| < r\}$. + +\subsection{Függvény} + +$\emptyset \neq A, B$ halmazok, $f \subset A \times B$ reláció. Valamely $x \in A$ elemre legyen $f_{x} := \{y \in B: (x,y) \in f\}$. $f$ reláció függvény, ha $\forall x \in A$-ra az $f_{x}$ halmaz legfeljebb egy elemű. + +\section{Függvények folytonossága} + +Az $f \in \mathbb{K}_{1} \to \mathbb{K}_{2}$ függvény az $a \in \mathcal{D}_{f}$ pontban folytonos, ha $\forall \varepsilon > 0$ számhoz megadható olyan $\delta > 0$ szám, amellyel bármely $x \in \mathcal{D}_{f}, |x-a| < \delta$ esetén $|f(x)-f(a)| < \varepsilon$. \\ +Jelölés: $f \in \mathcal{C}\{a\}$, ha $\forall x \in \mathcal{D}_{f} : f \in \mathcal{C}\{x\}$, akkor $f \in \mathcal{C}$. + +\section{Összefüggés határérték és folytonosság között} + +Legyen $f \in \mathbb{K}_{1} \to \mathbb{K}_{2}, a \in \mathcal{D}_{f} \cap \mathcal{D}'_{f}$. Ekkor $f \in \mathcal{C}\{a\} \iff \lim\limits_{a}{f} = f(a)$. + +\section{Fogalmak} + +\subsection{Kompakt halmaz} + +$A \subset \mathbb{K}$ kompakt, ha bármely $(x_{n}): \mathbb{N} \to A$ sorozatnak van olyan $(x_{\nu_{n}})$ részsorozata, amely konvergens és $\lim{(x_{\nu_{n}})} \in A$. \\ +Ekkor $A$ korlátos és zárt. + +\subsection{Konvergens} + +Egy $x = (x_{n}) : \mathbb{N} \to \mathbb{K}$ számsorozatot konvergensnek nevezünk, ha $\exists \alpha \in \mathbb{K}, \forall \varepsilon > 0, \exists N \in \mathbb{N}, \forall n \in \mathbb{N}, n > N : |x_{n}-\alpha| < \varepsilon$. \\ +$\alpha$ az $x$ sorozat határértéke. + +\subsection{Korlátos} + +Sorozatra: $x_{n}$ korlátos $\Rightarrow \exists \nu : x \circ \nu$ konvergens \\ +Halmazra: $\emptyset \neq A \subset \mathbb{K}$ korlátos, ha $\exists q \in \mathbb{R} : |x| \leq q, (x \in A)$ + +\subsection{Zárt halmaz} + +Komplementere nyílt halmaz. + +\subsection{Nyílt halmaz} + +$A$ nyílt halmaz $\iff \forall a \in A, \exists K(a): K(a) \subset A$, vagyis az $A$ halmaz minden pontja belső pont. + +\section{Heine-tétel {\large (opcionális)}} + +Ha az $f \in \mathbb{K}_{1} \to \mathbb{K}_{2}$ függvény folytonos és $\mathcal{D}_{f}$ kompakt, akkor $f$ egyenletesen folytonos. + +\subsection{Egyenletesen folytonos} + +$f \in \mathbb{K}_{1} \to \mathbb{K}_{2}$ függvény egyenletesen folytonos, ha $\forall \varepsilon > 0, \exists \delta > 0 : |f(x)-f(t)| < \varepsilon, (x,t \in \mathcal{D}_{f}, |x-t| < \delta)$. + +\section{Weierstrass-tétel} + +Tegyük fel, hogy az $f \in \mathbb{K} \to \mathbb{R}$ függvény folytonos és $\mathcal{D}_{f}$ kompakt. Ekkor az $\mathcal{R}_{f}$ értékkészletnek van legnagyobb és legkisebb eleme $(\exists \max{\mathcal{R}_{f}}, \exists \min{\mathcal{R}_{f}})$. + +\section{Bolzano-tétel} + +Tegyük fel, hogy valamely $-\infty < a < b < +\infty$ esetén az $f:[a,b] \to \mathbb{R}$ függvény folytonos, és $f(a) \cdot f(b) < 0$ (ellenkező előjelű). \\ +Ekkor van olyan $\xi \in (a,b)$, amelyre $f(\xi) = 0$. + +\section{A hatványsor fogalma} + +Legyen adott az $a \in \mathbb{K}$ középpont és az $(a_{n}): \mathbb{N} \to \mathbb{K}$ együttható-sorozat, továbbá ezek segítségével tekintsük az alábbi függvényeket: $f_{n}(t) := a_{n}(t-a)^{n}, (t \in \mathcal{D} := \mathbb{K}, n \in \mathbb{N})$. Ekkor a $\sum{(f_{n})}$ függvénysort hatványsornak nevezzük. + +\subsection{Sorozat} + +Az $f$ függvényt sorozatnak nevezzük, ha $\mathcal{D}_{f} = \mathbb{N}$. + +\subsection{Függvénysorozat, függvénysor} + +$(f_{n})$ sorozat függvénysorozat, ha $\forall n \in \mathbb{N}$ esetén $f_{n}$ függvény, és valamilyen $\mathcal{D} \neq \emptyset$ halmazzal $\mathcal{D}_{f_{n}} = \mathcal{D}, (n \in \mathbb{N})$. \\ +Ha a szóban forgó $(f_{n})$ függvénysorozatra $\mathcal{R}_{f_{n}} \subset \mathbb{K}, (n \in \mathbb{N})$ is igaz, akkor az $(f_{n})$ függvénysorozat által meghatározott $\sum{(f_{n})}$ függvénysor a következő függvénysorozat: $\sum{(f_{n})} := (\sum\limits_{k=0}^{n}{f_{k}})$. + +\section{Cauchy--Hadamard-tétel} + +Tegyük fel, hogy az $(a_{n}) : \mathbb{N} \to \mathbb{K}$ sorozat esetén létezik a $\lim{(\sqrt[n]{|a_{n}|})}$ határérték, és legyen +$$ r := \left\{\begin{array} {lr} + +\infty & ha \lim{(\sqrt[n]{|a_{n}|})} = 0 \\ + \dfrac{1}{\lim{(\sqrt[n]{|a_{n}|})}} & ha \lim{(\sqrt[n]{|a_{n}|})} > 0 + \end{array}\right.$$ +$r$-t a konvergenciasugárnak nevezzük. +Ekkor bármely $a \in \mathbb{K}$ mellett a $\sum{(a_{n}(t-a)^{n})}$ hatványsorról a következőket mondhatjuk: +\begin{enumerate} + \item Ha $r > 0$, akkor minden $x \in \mathbb{K}, |x-a| < r$ helyen a $\sum{(a_{n}(t-a)^{n})}$ hatványsor az $x$ helyen abszolút konvergens. + \item Ha $r < +\infty$, akkor tetszőleges $x \in \mathbb{K}, |x-a| > r$ mellett a $\sum{(a_{n}(t-a)^{n})}$ hatványsor az $x$ helyen divergens. +\end{enumerate} + +\subsection{Abszolút konvergens} + +A $\sum\limits_{n=1}^{\infty}{a_{n}}$ végtelen sort abszolút konvergensnek nevezzük, ha a $\sum\limits_{n=1}^{\infty}{|a_{n}|}$ sor konvergens. + +\subsection{Divergens} + +Ha a $\lim\limits_{n \to \infty}{a_{n}}$ nem létezik, vagy nem véges, akkor a $\sum{a_{n}}$ végtelen sor divergens. + +\subsection{Cauchy--Hadamard-tételből következik} + +\begin{enumerate} + \item Ha $r = +\infty$, akkor $\mathcal{D}_{0} = \mathbb{K}$, és $\forall x \in \mathbb{K}$-ra a hatványsor abszolút konvergens. + \item Ha $r = 0$, akkor $\mathcal{D}_{0} = \{a\}$ és $\sum\limits_{n=0}^{\infty}{a_{n}(a-a)^{n}} = a_{0}$. + \item Ha $0 < r < +\infty$, akkor $K_{r}(a) \subset \mathcal{D}_{0} \subset G_{r}(a) = \{x \in \mathbb{K} : |x-a| \leq r\}$ és a $K_{r}(a)$ környezet $\forall x$ pontjára a hatványsor az $x$ helyen abszolút konvergens. + \item Ha $r > 0$, akkor tetszőleges $0 \leq \rho < r$ számhoz válasszuk az $x \in K_{r}(a)$ elemet úgy, hogy $|x-a| = \rho$. Ekkor $\sum\limits_{n=0}^{\infty}{|a_{n}(x-a)^{n}|} = \sum\limits_{n=0}^{\infty}{|a_{n}||x-a|^{n})} = \sum\limits_{n=0}^{\infty}{|a_{n}|\rho^{n})} < +\infty$ +\end{enumerate} + +\section{Analitikus függvények} + +Tegyük fel, hogy a $\sum{(a_{n}(t-a)^{n})}$ hatványsor $r$ konvergenciasugara (ld. C--H-tétel) nem nulla. Ekkor értelmezhetjük az alábbi függvényt: $f(x) := \sum\limits_{n=0}^{\infty}{a_{n}(x-a)^{n}}, (x \in K_{r}(a))$, ami nem más, mint a $\sum{(a_{n}(t-a)^{n})}$ függvénysor $F(x) := \sum\limits_{n=0}^{\infty}{a_{n}(x-a)^{n}}, (x \in \mathcal{D}_{0})$ összegfüggvényének a leszűkítése a $K_{r}(a)$ környezetre: $f = F|_{K_{r}(a)}$, ($f$ a hatványsor összegfüggvénye). Az ilyen szerkezetű $f$ függvényt analitikusnak nevezzük. \\ +Megjegyzés: $\mathcal{D}_{0}$ a $\sum{(a_{n}(t-a)^{n})}$ hatványsor konvergenciatartományát jelöli. + +\subsection{Fontos analitikus függvények} + +Olyan $a_{n}$-ek, amire $\lim{(\sqrt[n]{|a_{n}|})} = 0$, tehát $r = +\infty$ a $\sum{(a_{n}t^{n})}$ hatványsorok esetén. \vspace{0.3cm} \\ +Ezek az $a_{n}$-ek: $\dfrac{1}{n!}, \dfrac{(-1)^n}{(2n+1)!}, \dfrac{(-1)^n}{(2n)!}, \dfrac{1}{(2n+1)!}, \dfrac{1}{(2n)!}$. +\begin{itemize} + \item $\exp{x} := \exp{(x)} = e^{x} = \sum\limits_{n=0}^{\infty}{\dfrac{x^n}{n!}, (x \in \mathbb{K})}$ + \item $\sin{x} := \sin{(x)} = \sum\limits_{n=0}^{\infty}{(-1)^n\dfrac{x^{2n+1}}{(2n+1)!}, (x \in \mathbb{K})}$ + \item $\cos{x} := \cos{(x)} = \sum\limits_{n=0}^{\infty}{(-1)^n\dfrac{x^{2n}}{(2n)!}, (x \in \mathbb{K})}$ + \item $\sinh{x} := \sinh{(x)} = \sum\limits_{n=0}^{\infty}{\dfrac{x^{2n+1}}{(2n+1)!}, (x \in \mathbb{K})}$ + \item $\cosh{x} := \cosh{(x)} = \sum\limits_{n=0}^{\infty}{\dfrac{x^{2n}}{(2n)!}, (x \in \mathbb{K})}$ +\end{itemize} + +\end{document} \ No newline at end of file diff --git a/10. Programnyelvi alapok/10. Programnyelvi alapok.pdf b/10. Programnyelvi alapok/10. Programnyelvi alapok.pdf new file mode 100644 index 0000000..7b79fd0 Binary files /dev/null and b/10. Programnyelvi alapok/10. Programnyelvi alapok.pdf differ diff --git a/10. Programnyelvi alapok/10. Programnyelvi alapok.tex b/10. Programnyelvi alapok/10. Programnyelvi alapok.tex new file mode 100644 index 0000000..330db0e --- /dev/null +++ b/10. Programnyelvi alapok/10. Programnyelvi alapok.tex @@ -0,0 +1,1204 @@ +\documentclass[margin=0px]{article} + +\usepackage{listings} +\usepackage[utf8]{inputenc} +\usepackage{graphicx} +\usepackage{float} +\usepackage[a4paper, margin=0.7in]{geometry} +\usepackage{amsthm} +\usepackage{amssymb} +\usepackage{fancyhdr} +\usepackage{setspace} + +\onehalfspacing + +\renewcommand{\figurename}{ábra} +\makeatletter +\renewcommand\paragraph{% + \@startsection{paragraph}{4}{0mm}% + {-\baselineskip}% + {.5\baselineskip}% + {\normalfont\normalsize\bfseries}} +\makeatother +\renewcommand{\figurename}{ábra} +\newenvironment{tetel}[1]{\paragraph{#1 \\}}{} + +\pagestyle{fancy} +\lhead{\it{PTI BSc Záróvizsga tételek}} +\rhead{10. Programnyelvi alapok} + +\title{\textbf{{\Large ELTE IK - Programtervező Informatikus BSc} \vspace{0.2cm} \\ {\huge Záróvizsga tételek}} \vspace{0.3cm} \\ 10. Programnyelvi alapok} +\author{} +\date{} + +\begin{document} +\maketitle + +\begin{tetel}{Programnyelvi alapok} + Fordítás és szerkesztés, programozási nyelv szabályrendszere. Lexikális elemek, szintaxis, szemantikus szabályok. Kifejezések kiértékelésének szabályai. Utasítások, vezérlési szerkezetek. Alaptípusok ábrázolása. Összetett típusok. Programszerkezet, hatókör, láthatóság. Változók ábrázolása a memóriában, élettartam. Paraméterátadás. Kivételek. +\end{tetel} + +\section{Fordítás és Interpretálás} + +\subsection{Fordítás} + +A fordítás során általában egy magas szintű programozási nyelvből gépi kód keletkezik, amelyet a processzor már képes értelmezni és futtatni. Előnye, hogy gyors, mivel a lexikális, szintaktikus és szemantikus elemzés fordítási időben, egyszer fut le, valamint ekkor optimalizáljuk a kódot. Fordítási időben sok hibát ki lehet szűrni, ezáltal megkönnyítve a debugolást. A gépi kód nehezen visszafejthető. Általában nagyobb programokhoz használjuk, ahol fontos a hatékonyság. A lefordított kódon később már nem (vagy csak nagyon nehezen) tudunk változtatni. + +Hátránya, hogy a keletkezett kód nem platformfüggetlen, minden architektúrára külön-külön le kell fordítani. + +\textbf{Példák}: C, C++, Ada, Haskell + +\begin{figure}[H] + \centering + \includegraphics[width=0.5\textwidth]{img/forditas_folyamatabra.png} + \caption{a fordítás folyamata} + \label{fig:forditas_folyamatabra} +\end{figure} + + +\subsection{Interpretálás} + +Az interpretálás során a programkódot az értelmező futás közben hajtja végre. Platformfüggetlen, csak az interpretert kell minden rendszerre egyszer megírni. Nehéz benne a hibakeresés, mivel sok olyan hiba maradhat a kódban, amit egy fordító kiszűrt volna (pl. típus egyezőség). + +\textbf{Példák}: PHP, JavaScript, ShellScript + + +\begin{figure}[H] + \centering + \includegraphics[width=0.5\textwidth]{img/interpretalas_folyamatabra.png} + \caption{az interpretálás folyamata} + \label{fig:interpretalas_folyamatabra} +\end{figure} + + +\subsection{Fordítás és Interpretálás együtt} + +Egyes nyelvek (pl. Java) előfordítást használnak, melynek eredménye a \textit{bájtkód}, amely gépi kód egy virtuális gép számára. Ezzel elérhető a fordítási idejű hibaellenőrzés és optimalizálás, de megmarad a platformfüggetlenség. + +\begin{figure}[H] + \centering + \includegraphics[width=0.5\textwidth]{img/bajtkod_folyamatabra.png} + \caption{az interpretálás folyamata} + \label{fig:bajtkod_folyamatabra} +\end{figure} + +\section{Fordítási egység és a szerkesztés} + +A tárgykód létrehozása két fázisban történik. Először a forrásfájlokat \textit{lefordítjuk}, ebből keletkezik az un. \textit{objektumkód} (pl.: .obj, .class). Ebben a gépi utasítások már megvannak, de hiányzik belőle a hivatkozások (pl változók, függvények), melyek más fájlokban vannak megvalósítva. \textit{Fordítási egységnek} nevezzük azt, amiből egy objektumkód keletkezik. + +A \textit{linker} (szerkesztő) feladata, hogy a hiányzó referenciákat kitöltse, hogy egyetlen fájlt generálva futtatható kódot kapjunk. + +A linkelés lehet statikus, amikor a fordító tölti fel a hiányzó referenciákat; vagy dinamikus, mikor fordítási időben, jellemzően egy másik fájlból (pl.: .dll) tölti be a hiányzó kódot. Az utóbbi akkor praktikus, ha egy modult több, különálló program használ. + + +\section{A fordítóprogram komponensei} +\begin{figure}[H] + \centering + \includegraphics[width=0.5\textwidth]{img/forditas_teljes_folyamata.png} + \caption{a fordítás lépései} + \label{fig:forditas_teljes_folyamatabra} +\end{figure} + + +\subsection{Lexikális elemző} + +Bemenete maga a forráskód. A lexikális elemző feladata, hogy tokenekre bontsa a forráskódot. Adott egy reguláris (hármas típusú) nyelvtan, mely a nyelvre jellemző. Ez adja meg, hogy milyen típusú tokenek szerepelhetnek a forrásban. A tokenekhez tulajdonságokat rendelhet (pl. változó neve, literál értéke). Kimenete ez a tokensorozat. Amennyiben az elemző olyan karaktersorozatot talál, amelynek nem feleltethető meg token, akkor az lexikális hibát vált ki. + +\textit{megjegyzés: Lexikális hibánál nem feltétlen szakad meg a fordítás folyamata, megpróbálhatjuk átugrani az adott részt és folytatni az elemzést, így ha több hiba is van, akkor azokat egyszerre jelezhetjük.} + +A reguláris kifejezéseket \textit{véges determinisztikus automatákkal} ismerjük fel. Amennyiben egy lexikális elemre az egyik automata elfogadó állapotba kerül, úgy felismertünk egy tokent. Egy karaktersorozatot egyszerre több automata is felismerhet. Amennyiben ezek azonosan hosszúak, akkor a nyelv konfliktusos. Ennek nem szabad előfordulnia. Az viszont lehetséges, hogy egy szót, és az ő prefixét is felismerte egy automata. Ekkor mindig a hosszabbat választjuk. + +\subsection{Szintaktikus elemző} + +Bemenete a lexikális elemző kimenete. Feladata, hogy \textit{szintaxisfát} építsen a tokenekből, a nyelvez tartozó egy környezetfüggetlen (kettes típusú) grammatika alapján, vagy ha ez lehetetlen, akkor jelezze ezt \textit{szintaktikus hiba}ként. + +\subsubsection{LR0 elemzés} + +A lexikális elemző által előállított szimbólumsorozatot balról +jobbra olvassuk, a szimbólumokat az elemző vermébe tesszük. + +\textit{Léptetés}: egy új szimbólumot teszünk a bemenetről a verem +tetejére. + +\textit{Redukálás}: a verem tetején lévő szabály-jobboldalt +helyettesítjük a szabály bal oldalán álló nemterminálissal + +A háttérben egy véges determinisztikus automata működik: +az automata átmeneteit a verem tetejére kerülő szimbólumok +határozzák meg +ha az automata végállapotba jut, redukálni kell +egyéb állapotban pedig léptetni. + +Az automata bizonyos nyelvek esetén konfliktusos lehet: nem tudjuk eldönteni, hogy léptessünk vagy redukáljunk. + +\subsubsection{LR1 elemzés} + +Az előző problémára kínál megoldást, kibővítve a lehetséges nyelvek halmazát. + +Az ötlet, hogy \textit{olvassunk előre} egy szimbólumot. + +Ha az aktuális állapot \textit{i}, és az előreolvasás eredménye az a +szimbólum: + +ha $ [A \rightarrow \alpha.a\beta, b] \in I_i $ és $read(I_i, a) = I_j$ +akkor léptetni kell, és átlépni a \textit{j} állapotba. + + +ha $ [A \rightarrow \alpha., a] \in I_i (A \neq S'), $ +akkor redukálni kell az $ A \rightarrow \alpha $ szabály szerint. + + + + +ha $ [S' \rightarrow S., \#] \in I_i $ és $ a = \# $, akkor el kell fogadni a szöveget, minden más esetben hibát kell jelezni. + +Ha az \textit{i} állapotban \textit{A} kerül a verem tetejére: +ha$ read(I_i,A) = I_j $ , +akkor át kell lépni a \textit{j} állapotba, egyébként hibát kell jelezni. + + + +\subsubsection{Jelmagyarázat/Kanonikus halmazok} + +\paragraph{Closure/lezárás} + +Ha $ I $ a grammatika egy $ LR(1) $ elemhalmaza, akkor $ closure(I) $ a +legszűkebb olyan halmaz, amely az alábbi tulajdonságokkal +rendelkezik: + +$ I \subseteq closure(I) $ ha $ [A \rightarrow \alpha.B\gamma,a] \in closure(I) $, + +és $ B \rightarrow \beta $ a grammatika egy szabálya, +akkor $ \forall b \in FIRST1(\gamma{}a) $ esetén $ [B \rightarrow .\beta,b] \in closure(I) $ + + +\paragraph{Read/olvasás} +Ha $ I $ a grammatika egy $ LR(1) $ elemhalmaza, $ X $ pedig terminális vagy nemterminális szimbóluma, akkor $ read(I, X) $ a legszűkebb olyan halmaz, amely az alábbi tulajdonsággal rendelkezik: + +Ha $ [A \rightarrow \alpha. X\beta,a] \in I $, akkor $ closure([ A \rightarrow \alpha X.\beta,a]) \subseteq read(I, X) $. + + +\paragraph{LR(1) kanonikus halmazok ($ I_n $)} +\begin{itemize} + \item + $ closure([S' \rightarrow .S, \#]) $ a grammatika egy kanonikus halmaza. + \item + Ha $ I $ a grammatika egy kanonikus elemhalmaza, $ X $ egy terminális vagy nemterminális szimbóluma, és $ read(I, X) $ nem üres, akkor $ read(I, X) $ is a grammatika egy kanonikus halmaza. + \item + Az első két szabállyal az összes kanonikus halmaz előáll. +\end{itemize} + + + + +\subsection{Szemantikus elemző} + + +A szemantikus elemzés jellemzően a környezetfüggő ellenőrzéseket +valósítja meg. + +%Dévai diáiról +\begin{itemize} + \item + deklarációk kezelése: változók, függvények, eljárások, operátorok, típusok + \item + láthatósági szabályok + \item + aritmetikai ellenőrzések + \item + a program szintaxisának környezetfüggő részei + \item + típusellenőrzés + \item + stb. +\end{itemize} + + +A szemantikus elemzéshez ki kell egészítenünk a grammatikát. Rendeljünk a szimbólumokhoz attribútumokat és a szabályokhoz akciókat! Egy adott szabályhoz tartozó feltételek csak a szabályban előforduló attribútumoktól függhetnek. (Ha egy feltétel nem teljesül, akkor szemantikus hibát kell jelezni!). A szemantikus rutinok csak annak a szabálynak az attribútumait használhatják és számíthatják ki, amelyikhez az őket reprezentáló akciószimbólum tartozik. Minden szintaxisfában minden attribútumértéket pontosan egy +szemantikus rutin határozhat meg. Az így létrejövő nyelvtant \textit{attribútum fordítási grammatikának} (ATG) hívjuk. + +A \textit{jól definiált attribútum fordítási grammatika}, olyan attribútum fordítási grammatika, amelyre igaz, hogy a grammatika által definiált nyelv mondataihoz tartozó minden szintaxisfában minden attribútum értéke egyértelműen kiszámítható. + +Egy attribútumot kétféleképpen lehet meghatározni: + +\paragraph{Szintézissel} a szintaxisfában alulról felfelé terjed az információ, egy szülő attribútumát a gyerekekből számoljuk. Kitüntetettnek hívjuk azokat az attribútumokat, melyeket a lexikális elemző szolgáltat. + +\paragraph{Öröklődéssel} a szintaxisfában felülről lefelé terjed az információ. A gyerekek attribútumait a szülőé határozza meg. + +Az \textit{L-ATG} olyan attribútum fordítási grammatika, amelyben minden +$ A \rightarrow X_1X_2 . . . X_n $szabályban az attribútumértékek az alábbi sorrendben meghatározhatók: + +\begin{itemize} + \item + A örökölt attribútumai + \item + $ X_1 $ örökölt attribútumai + \item + $ X_1 $ szintetizált attribútumai + \item + $ X_2 $ örökölt attribútumai + \item + $ X_2 $ szintetizált attribútumai + \item + \dots + \item + $ X_n $ örökölt attribútumai + \item + $ X_n $ szintetizált attribútumai + \item + A szintetizált attribútumai +\end{itemize} + +Amennyiben a nyelvtanunk ennek eleget tesz, úgy hatékonyan meghatározható minden attribútum. + +A szemantikus elemzéshez jellemzően szimbólumtáblát használunk, verem szerkezettel és keresőfával vagy hash-táblával. Minden blokk egy új szint a veremben, egy szimbólum keresése a verem tetejéről indul. + +\section{Kifejezések kiértékelésének szabályai} + +\noindent Fogalmak: +\begin{itemize} + \item Operandusok: Változók, konstansok, függvény- és eljáráshívások. + + \item Operátorok: Műveleti jelek, amelyek összekapcsolják egy kifejezésben az operandusokat és valamilyen + műveletet jelölnek. + + \item Kifejezés: operátorok és operandusok sorozata + + \item Precedencia: A műveletek kiértékelési sorrendjét határozza meg. + + \item Asszociativitás iránya: Az azonos precedenciájú operátorokat tartalmazó kifejezésekben a kiértékelés iránya. + Megkülönböztetünk bal-asszociatív és jobb-asszociatív operátorokat. +\end{itemize} + +\noindent Az operátorokat háromféleképpen írhatjuk az operandusokhoz képest: + +\begin{itemize} + \item Infix : Egy operátort a két operandusa közé kell írni (tehát csak kétoperandusú műveletek operátorait + lehet így írni). + Amikor egy kifejezésben több operátor is szerepel, akkor a különböző operátorok végrehajtási + sorrendjét az operátorok precedenciája dönti el. Amelyik operátor precedenciája magasabb (pl. a + szorzásé magasabb, mint az összeadásé), az általa jelölt műveletet értékeljük ki először. Ugyanazon + operátorok végrehajtási sorrendjét pedig az asszociativitás iránya dönti el (pl. a bal-asszociatív azt + jelenti, hogy balról jobbra haladva kell végrehajtani). Ezeket a (programozási nyelvekbe beépített) + szabályokat zárójelek segítségével lehet felülírni.\\ + Példa: A * (B + C) / D + + \item Postfix (Lengyelforma) : Az operátorokat az operandusaik mögé írjuk. A kiértékelés sorrendje mindig balról jobbra + történik – tehát egy n operandusú operátor a tőle balra levő első n operandusra érvényes.\\ + Példa: A B C + * D /\\ + Ugyanez zárójelezve (felesleges): ((A (B C +) *) D /) + + \item Prefix : Az operátorokat az operandusuk elé írjuk. A kiértékelés sorrendje balról + jobbra történik.\\ + Példa: / * A + B C D\\ + Ugyanez zárójelezve (felesleges): (/ (* A (+ B C) ) D)\\ + Habár a prefix operátorok esetén is balról jobbra történik a kiértékelés, viszont ha egy operátortól + jobbra egy másik operátor következik, akkor értelemszerűen az ehhez az operátorhoz tartozó + műveletet kell először végrehajtani, hogy a bal oldalit is végre tudjuk hajtani. A fenti példában is a + szorzást az osztás előtt, az összeadást pedig a szorzás előtt kell elvégezni. +\end{itemize} + +\paragraph{Logikai operátorokat tartalmazó kifejezések kiértékelése} + +\noindent Az ilyen kifejezéseknek kétféle kiértékelése létezik: +\begin{itemize} + \item Lusta kiértékelés : Ha az első argumentumból meghatározható a kifejezés értéke, akkor a másodikat + már nem értékeli ki. + \item Mohó kiértékelés : Mindenféleképpen megállapítja mindkét argumentum logikai értékét. +\end{itemize} + +\noindent A két kiértékelési módszer bizonyos esetekben különböző eredményt adhat: +\begin{itemize} + \item A 2. argumentum nem mindig értelmes\\ + Példa (C++): + \begin{verbatim} + if ((i>=0) && (T[i]>=10)) + { + //... + } + \end{verbatim} + Tegyük fel, hogy a T egy \texttt{int} tömb, 0-tól indexelődik. + Itt ha az $i>=0$ hamis, akkor T-t alul indexelnénk. Ez mohó kiértékelés esetén futási idejű hibát okozna. + Lusta kiértékelés esetén (a C++ alapértelmezetten ezt használja) viszont tudhatjuk, hogy a feltétel már nem lehet igaz, emiatt $T[i]>=10$-et már nem kell kiértékelni. + \item A 2. argumentumnak van valamilyen mellékhatása.\\ + Példa (C++): + \begin{verbatim} + if ((i>0) || (++j>0)) + { + T[j] = 100; + } + \end{verbatim} + Ebben az esetben ha $i>0$ igaz, akkor a feltétel biztosan igaz, viszont a $++j>0$ kifejezés mellékhatásos, növeli j értékét. + Mivel a C++ lusta kiértékelést használ a $||$ operátor esetén ($|$ operátor esetén mohó a kiértékelés), ezért ebben az esetben nem növeli j értékét. (csak akkor, ha $i>0$ hamis). +\end{itemize} + +\section{Utasítások, vezérlési szerkezetek} + +\subsection{Egyszerű utasítások} + +\begin{itemize} + \item Értékadás : Az értékadás bal oldalán egy változó, a jobb oldalán bármilyen kifejezés állhat. Az + értékadással a változóhoz rendeljük a jobb oldali kifejezést. Figyelni kell arra, hogy a bal oldali + változó típusának megfelelő kifejezés álljon a jobb oldalon (vagy létezik implicit konverzió, pl. C++-ban + az egész és logikai típus között). A legtöbb nyelvben az értékadás operátora az \texttt{=} (például C++, Java, C\#), + vagy a \texttt{:=} (például Pascal, Ada). + + \item Üres utasítás : Nem mindenhol lehet ilyet írni. A lényege, hogy nem csinál semmit. + Azokban a nyelvekben lehet létjogosultsága, ahol üres blokkot nem írhatunk, + muszáj legalább 1 utasításnak szerepelnie benne. (pl. Ada) Erre szolgál az üres utasítás. + (Ada-ban ez a \texttt{null} utasítás) + + \item Alprogramhívás : Alprogramokat nevük és paramétereik megadásával hívhatunk. + Példák: + \begin{itemize} + \item \texttt{System.out.println("Hello”);} + \item \texttt{int x = sum(3,4);} + \end{itemize} + \item Visszatérés utasítás : Az utasítás hatására az alprogram végrehajtása befejeződik. Ha az alprogram egy + függvény, akkor meg kell adni a visszatérési értéket is. + + \noindent Példák (C++): + \begin{itemize} + \item Ebben a példában a \texttt{doSomething} egy eljárás, nincs visszatérési értéke. A paraméterül kapott + x változót értékül adjuk a j-nek. Ha ez az érték nem 0, akkor visszatérünk, azaz megszakítjuk az alprogram + végrehajtását (konkrét értéket viszont nem adunk vissza). Ha ez az érték 0, akkor a végrehajtás folytatódik tovább, + meghívjuk a \texttt{doSomethingElse} függvényt a j paraméterrel. + \begin{verbatim} + void doSomething(int x) + { + int j; + if(j=x) + return; // j!=0, do nothing + + doSomethingElse(j); + } + \end{verbatim} + + \item Ebben a példában az \texttt{isOdd} egy függvény, \texttt{int} visszatérési értékkel. Megmondja a paraméterül kapott + x egész számról, hogy páratlan-e. Ehhez bitenkénti ÉS művelettel "összeéseli" az x-et az 1-gyel (0...01). Ha az eredmény + nem 0, akkor páratlan, visszatérünk igaz értékkel. Különben folytatjuk a működést, majd visszatérünk hamis értékkel. + \begin{verbatim} + int isOdd(int x) + { + if(x & 1) //bitwise AND with 0...01 is not 0...0 + return true; + + return false; + } + \end{verbatim} + \end{itemize} + + \item Utasításblokk: A blokkon belüli utasítások "összetartoznak”. + Ez több esetben is jól alkalmazható nyelvi elem: + \begin{itemize} + \item Vezérlési szerkezetekben: Az adott vezérlési szerkezetekhez tartozó utasításokat különíthetjük el. + + \item Az olyan nyelvekben, amelyekben deklaráció csak a program elején található deklarációs + blokkokban lehetséges (pl. Ada), van lehetőség arra, hogy a programkód későbbi részében nyissunk + egy blokkot, ahol deklarációk is szerepelhetnek. + + \item Osztályok inicializáló blokkja pl. Java-ban (konstruktor előtt hajtódik végre): + \begin{verbatim} + public class MyClass{ + private ResourceSet resourceSet; + + { + resourceSet = new ResourceSetImpl(); + UMLResourcesUtil.init(resourceSet); + } + + /* ... */ + } + \end{verbatim} + \item Osztályok statikus inicializáló blokkja pl. Java-ban: + \begin{verbatim} + public class MyClass{ + private static ResourceSet resourceSet; + + static{ + resourceSet = new ResourceSetImpl(); + UMLResourcesUtil.init(resourceSet); + } + + /* ... */ + } + \end{verbatim} + + \end{itemize} + +\end{itemize} + +\subsection{Vezérlési szerkezetek} + +\begin{itemize} + \item Elágazás : Az elágazás egy olyan vezérlési szerkezet, amellyel meghatározhatjuk, hogy bizonyos + (blokkban megadott) utasítások csak a megadott feltétellel jöhessenek létre. + Általában több feltételt is megadhatunk egymás után (if L1 then … else if L2 then … else if L3 then …). + Megadhatjuk azt is, hogy mi történjen, ha egyik feltétel sem teljesül (if L then … else …). + + Elágazásokat lehet egymásba ágyazni (if … then if ...). + + "Csellengő else” ("Dangling else”) probléma: Azokban a nyelvekben lép fel, ahol egy feltétel egy + utasításblokkját nem zárja le külön kódszó (pl. endif). Ekkor abban az esetben, ha elágazásokat + egymásba ágyazunk, a következő probléma léphet fel:\\ + Példa: \texttt{if (A>B) then if (C>D) then E:=100; else F:=100;} + + A fenti esetben nem lehet megállapítani, hogy a programozó az else kulcsszót melyik elágazásra + értette. + + \item Ciklus : Egy utasításblokk (ciklusmag) valahányszori végrehajtását jelenti. + \begin{itemize} + \item Feltétel nélküli ciklus : Végtelen ciklust kódol, kilépni belőle a strukturálatlan utasításokkal lehet + (ld. lentebb), vagy return-nel, esetleg hiba fellépése esetén. + + Példa (ADA): + \begin{verbatim} + loop + null; + end loop; + \end{verbatim} + + \item Elöltesztelő ciklus : A ciklus a ciklusmag minden végrehajtása előtt megvizsgálja, hogy az adott + feltétel teljesül-e. Ha teljesül, akkor végrehajtja a magot, majd újra ellenőriz. Különben a ciklus + után folytatódik a futás. + + Példák: + \begin{itemize} + \item C++: + \begin{verbatim} + int x=0,y=0; + while(x<5 && y<5) + { + x+=y+1; + y=x-1; + } + cout<0) + return n * fact (n-1); + else + return 1; + } + \end{verbatim} + + \item Haskell: + \begin{verbatim} + fact :: (Integral a) => a -> a + fact n + | n>0 = n * fact (n - 1) + | otherwise = 0 + \end{verbatim} + +\end{itemize} + +\section{Kódgenerálás alapvető vezérlési szerkezetekhez} + + +A kódgenerálás feladata, hogy a szintaktikusan és szemantikusan elemzett programot tárgykóddá alakítsa. Általában szorosan összekapcsolódik a +szemantikus elemzéssel. + +\subsection{Értékadás} + +assignment $ \rightarrow $ variable assignmentOperator expression + +\begin{verbatim} + a kifejezést az eax regiszterbe kiértékelö kód + 2 mov [Változó],eax + \end{verbatim} + +\subsection{Egy ágú elágazás} +statement $ \rightarrow $ if condition then program end + +\begin{verbatim} + 1 a feltételt az al regiszterbe kiértékelö kód + 2 cmp al,1 + 3 je Then + 4 jmp Vége + 5 Then: a then-ág programjának kódja + 6 Vége: + \end{verbatim} + +\textit{megjegyzés: a dupla ugrásra azért van szükség, mert a feltételes ugrás hatóköre limitált.} + +\subsection{Több ágú elágazás} + + +statement $ \rightarrow $ +\\if $ condition_1 $ then $ program_1 $ +\\elseif $ condition_2 $ then $ program_2 $ +\\\dots +\\elseif $ condition_n $ then $ program_n $ +\\else $ program_{n+1} $ end + +\begin{verbatim} + 1 az 1. feltétel kiértékelése az al regiszterbe + 2 cmp al,1 + 3 jne near Feltétel_2 + 4 az 1. ág programjának kódja + 5 jmp Vége + 6 + ... + 7 Feltétel_n: az n-edik feltétel kiértékelése az al regiszterbe + 8 cmp al,1 + 9 jne near Else + 10 az n-edik ág programjának kódja + 11 jmp Vége + 12 Else: az else ág programjának kódja + 13 Vége: + \end{verbatim} + +\subsection{Switch-case} +statement $ \rightarrow $ switch variable +\\case $ value_1 $ : $ program_1 $ +\\... +\\case $ value_n $ : $ program_n $ + +\begin{verbatim} + 1 cmp [Változó],Érték_1 + 2 je near Program_1 + 3 cmp [Változó],Érték_2 + 4 je near Program_2 + 5 + . .. + 6 cmp [Változó],Érték_n + 7 je near Program_n + 8 jmp Vége + 9 Program_1: az 1. ág programjának kódja + 10 + . .. + 11 Program_n: az n-edik ág programjának kódja + 12 Vége: + \end{verbatim} + +\subsection{Ciklus} +%Ez egy vagy két szó? +\subsubsection{Elől tesztelő} +statement $ \rightarrow $ while condition statements end + +\begin{verbatim} + 1 Eleje: a ciklusfeltétel kiértékelése az al regiszterbe + 2 cmp al,1 + 3 jne near Vége + 4 a ciklusmag programjának kódja + 5 jmp Eleje + 6 Vége: + \end{verbatim} + + +%Ez egy vagy két szó? +\subsubsection{Hátul tesztelő} +statement $ \rightarrow $ loop statements while condition + + +\begin{verbatim} + 1 Eleje: a ciklusmag programjának kódja + 2 a ciklusfeltétel kiértékelése az al regiszterbe + 3 cmp al,1 + 4 je near Eleje + \end{verbatim} + +\subsubsection{For ciklus} + +statement $ \rightarrow $ for variable from $ value_1 $ to $ value_2 $ statements end + + +\begin{verbatim} + 1 a "from" érték kiszámítása a [Változó] memóriahelyre + 2 Eleje: a "to" érték kiszámítása az eax regiszterbe + 3 cmp [Változó],eax + 4 ja near Vége + 5 a ciklusmag kódja + 6 inc [Változó] + 7 jmp Eleje + 8 Vége: + \end{verbatim} + +\subsection{Statikus változók} + +Kezdőérték nélküli változódefiníció fordítása: +\begin{verbatim} + section .bss + ; a korábban definiált változók... + Lab12: resd 1 ; 1 x 4 bájtnyi terület + \end{verbatim} + + +Kezdőértékkel adott változódefiníció fordítása: +\begin{verbatim} + section .data + ; a korábban definiált változók... + Lab12: dd 5 ; 4 bájton tárolva az 5-ös érték + \end{verbatim} + +\subsection{Logikai kifejezések} + +\subsubsection{kifejezés1 $ < $ kifejezés2 } + +\begin{verbatim} + ; a 2. kifejezés kiértékelése az eax regiszterbe + push eax + ; az 1. kifejezés kiértékelése az eax regiszterbe + pop ebx + cmp eax,ebx + jb Kisebb + mov al,0 ; hamis + jmp Vége + Kisebb: + mov al,1 ; igaz + Vége: + \end{verbatim} + +\subsubsection{kifejezés1 $ \lbrace $ és, vagy, nem, kizáróvagy $ \rbrace $ kifejezés2 } + +\begin{verbatim} + ; a 2. kifejezés kiértékelése az al regiszterbe + push ax ; nem lehet 1 bájtot a verembe tenni! + ; az 1. kifejezés kiértékelése az al regiszterbe + pop bx ; bx-nek a bl részében van, + ; ami nekünk fontos + and al,bl + \end{verbatim} + +\subsubsection{ lusta "és" kiértékelés } + +\begin{verbatim} + ; az 1. kifejezés kiértékelése az al regiszterbe + cmp al,0 + je Vége + push ax + ; a 2. kifejezés kiértékelése az al regiszterbe + mov bl,al + pop ax + and al,bl + Vége: + \end{verbatim} + + +\subsubsection{ Alprogramok megvalósítása } + + +\begin{verbatim} + ; az 1. kifejezés kiértékelése az al regiszterbe + cmp al,0 + je Vége + push ax + ; a 2. kifejezés kiértékelése az al regiszterbe + mov bl,al + pop ax + and al,bl + Vége: + \end{verbatim} + +\subsubsection{ Alprogramok hívása } + +\begin{verbatim} + Alprogramok sémája + ; utolsó paraméter kiértékelése eax-be + push eax + ; ... + ; 1. paraméter kiértékelése eax-be + push eax + call alprogram + add esp,’a paraméterek összhossza’ + \end{verbatim} + +\section{Kódoptimalizáló} + +Az optimalizálás feladata, hogy a keletkezett kód kisebb és gyorsabb legyen, úgy hogy a futás eredménye nem változik. A gyorsaság és a tömörség gyakran ellentmondanak egymásnak, és az egyik csak a másik rovására lehet javítani. Általában három lépésben szokás elvégezni: + +\begin{itemize} + \item + Optimalizálási lépések végrehajtása az eredeti programon (vagy annak egyszerűsített változatán) + \item + Kódgenerálás + \item + Gépfüggő optimalizálás végrehajtása a generált kódon +\end{itemize} + +\subsection{Lokális optimalizáció} + +Egy programban egymást követő utasítások sorozatát \textit{alapblokknak} nevezzük, ha az első utasítás kivételével egyik utasítására sem lehet távolról átadni a vezérlést (assembly programokban: ahová a jmp, call, ret utasítások "ugranak"; magas szintű nyelvekben: eljárások, ciklusok eleje, elágazások ágainak első utasítása, goto utasítások célpontjai). Az utolsó utasítás kivételével nincs benne vezérlés-átadó utasítás (assembly programban: jmp, call, ret magas szintű nyelvekben: elágazás vége, ciklus vége, eljárás vége, goto). Az utasítás-sorozat nem bővíthető a fenti két szabály megsértése nélkül. + +Ha az optimalizálás az alapblokkok keretein belül történik, akkor garantált, hogy az átalakításnak nincs mellékhatása. Ez a \textit{lokális optimalizálás}. + +\paragraph{Ablakoptimalizálás} +Ez egy módszer a lokális optimalizálás egyes fajtáihoz. Egyszerre csak egy néhány utasításnyi részt vizsgálunk a kódból. A vizsgált részt előre megadott mintákkal hasonlítjuk össze. Ha illeszkedik, akkor a mintához megadott szabály szerint átalakítjuk ezt az "ablakot" végigcsúsztatjuk a programon. Az átalakítások megadása: +\begin{center} + $ \lbrace$ minta $ \rightarrow $ helyettesítés $\rbrace$ szabályhalmazzal + (a mintában lehet paramétereket is használni) +\end{center} + +Példák: +\begin{itemize} + \item + felesleges műveletek törlése: nulla hozzáadása vagy kivonása + \item + egyszerűsítések: nullával szorzás helyett a regiszter törlése + \item + regiszterbe töltés és ugyanoda visszaírás esetén a visszaírás elhagyható + \item + utasításismétlések törlése: ha lehetséges, az ismétlések törlése +\end{itemize} + + +\subsection{Globális optimalizáció} +A teljes program szerkezetét meg kell vizsgálni. Ennek módszere az adatáram-analízis: +\begin{itemize} + \item + Mely változók értékeit számolja ki egy adott alapblokk? + \item + Mely változók értékeit melyik alapblokk használja fel? +\end{itemize} + + +Ez lehetővé teszi az azonos kifejezések többszöri kiszámításának kiküszöbölését akkor is, ha különböző alapblokkokban szerepelnek; valamint a konstansok és változók továbbterjesztését alapblokkok között is elágazások, ciklusok optimalizálását. + +\section{A szekvenciális és párhuzamos/elosztott végrehajtás összehasonlítása} + +\subsection{Szekvenciális végrehajtás:} + +Ilyenkor a végrehajtás egy processzoron történik. Minden művelet atomi. Egy inputhoz egy output tartozik. Két szekvenciális program ekvivalens, ha ezek a párosok megegyeznek. Nem használja fel az összes rendelkezésre álló erőforrást. + + +\subsection{Párhuzamos végrehajtás:} + +Több processzoron hajtódik végre a program. A párhuzamos folyamatok egymással kommunikálva, szinkronban oldják meg az adott problémát. A konkurens program szétbontható elemi szekvenciális programokra, ezek a folyamatok. A folyamatok használhatnak közös erőforrásokat: pl. változók, adattípus objektumok, kommunikációs csatornák. + +A kommunikációt általában kétféleképpen szokták megvalósítani. +\paragraph{Osztott memóriával.} Ekkor szinkronizálni kell, hogy ki mikor fér hozzá, hogy ne legyen ütközés. + +\paragraph{Kommunikációs csatornával.} Garantálni kell, hogy ha egy folyamat üzenetet küld egy másiknak, akkor az meg is kapja azt, és jelezzen is vissza. Ügyelni kell, nehogy deadlock alakuljon ki. + + +\section{Típusok} + +\subsection{Tömb} + +A tömb (angolul array) olyan adatszerkezet, amelyet nevesített elemek csoportja alkot, melyekre sorszámukkal (indexükkel) lehet hivatkozni. Vektornak is nevezik, ha egydimenziós, mátrixnak esetenként, ha többdimenziós. A legtöbb programozási nyelvben minden egyes elemnek azonos adattípusa van és a tömb folytonosan helyezkedik el a számítógép memóriájában. A készítés módja alapján lehet: + +\begin{itemize} + \item statikus :a méret fix, deklarációban szabályozott + \item dinamikus tömb: a mérete változik, folyamatosan bővíthető +\end{itemize} + +\subsection{Rekord} + +A rekord egy összetett értékek leírásához használható konstrukció. Névvel és típussal ellátott összetevői vannak, ezeket mezőknek nevezzük. +Értékhalmaz a mezők értéktípusai által meghatározott alaphalmazok direktszorzata. + +\begin{figure}[H] + \centering + \includegraphics[width=0.7\linewidth]{img/rekord} + \caption{A rekord-típuskonstrukciók általános szintaxisa.} + \label{fig:rekord} +\end{figure} + +\noindent Műveletek: +\begin{itemize} + \item Szelekciós függvény (.mezőszelektor szintaxisú); + + \item konstrukciós függvény (Rekordtípus(mezőértékek) szintaxisú); + + \item elképzelhetők transzformációs függvények, amelyek a teljes rekordstruktúrát érintik. +\end{itemize} + +\noindent Példa rekordra és használatára C-ben: +\begin{verbatim} + //definition of Point + struct Point + { + int xCoord; + int yCoord; + }; + + const struct Point ORIGIN = {0,0}; + +\end{verbatim} + +\subsection{Osztály} + +Az osztály egy felhasználói típus, amelynek alapján példányok (objektumok) +hozhatók létre. Az osztály alapvetően attribútum és metódus (művelet) definíciókat +tartalmaz. Az osztály írja le az objektum típusát: megadja a tulajdonságait és azok +lehetséges értékeit (azaz a típusértékeket), valamint az objektumon végrehajtható műveleteket (típusműveletek).\\ + +\noindent Példa C++-ban: +\begin{verbatim} + //definition of Point + class Point { + private: + int xCoord; + int yCoord; + public: + //constructor + Point(int xCoord, int yCoord) : xCoord(xCoord),yCoord(yCoord) {} + + void Translate(int dx, int dy) { + xCoord+=dx; + yCoord+=dy; + } + + void Translate(Point delta) { + xCoord+=delta.xCoord; + yCoord+=delta.yCoord; + } + + int getX() { return xCoord; } + + int getY() { return yCoord; } + }; + + int main(int argc, char* argv[]) + { + Point point(0,0); + point.Translate(5,-2); + cout<; + function Square (X : Element_T) return Element_T; + \end{verbatim} + Itt a \texttt{with function} kezdetű sor végén az \texttt{is <>} azt jelenti, hogy ha az adott típusra már létezik * + művelet (pl. egész számokra), akkor nem kell külön megadni példányosításkor, a program automatikusan azt használja. + + A törzs: + \begin{verbatim} + function Square (X: Element_T) return Element_T is + begin + return X * X; -- The formal operator "*". + end Square; + \end{verbatim} + + \item A példányosításnak biztosítania kell mindent, amit a sablon specifikációja megkövetel tőle. + A következő példában a négyzetre emelő függvényt mátrixokra alkalmazzuk, feltéve, hogy definiáltuk a + mátrixszorzást. + \begin{verbatim} + with Square; + with Matrices; + procedure Matrix_Example is + function Square_Matrix is new Square + (Element_T => Matrices.Matrix_T, "*" => Matrices.Product); + A : Matrices.Matrix_T := Matrices.Identity; + begin + A := Square_Matrix (A); + end Matrix_Example; + \end{verbatim} +\end{itemize} + +Például a C++-ban a sablonszerződés nem így működik. Ott a sablon specifikációja az egész +definíció (emiatt sablonosztályokat csak teljes egészében header fájlokban definiálhatunk). +Példányosításkor ezt is ismerni kell, hogy tudjuk, hogyan példányosíthatunk. Az információelrejtés +elve tehát sérül. + +Más nyelvekben (pl. Java, funkcionális nyelvek) nem kell a sablonokat példányosítani – mindig ugyanaz a +megírt kód hajtódik végre, csak épp az aktuális paraméterekkel. Pl. Java-ban a típusparaméter fordításkor "elveszik", +csak futási időben derül ki. + +\section{Polimorfizmus} +A programozási nyelvekben és a típuselméletben a polimorfizmus egy egységes interfészre utal, amit különböző típusok valósítanak meg. Többalakúságot is jelent. A polimorf típuson végzett műveletek több különböző típus értékeire alkalmazhatók. Polimorfizmus többféleképpen is megvalósítható: +\begin{itemize} + \item {\textbf {Ad-hoc polimorfizmus:}} Egy függvénynek sok különböző implementációja van, amelyeket egyenként specifikálnak néhány különböző típus és kombinációja számára. Megvalósítható túlterheléssel. + \item {\textbf {Paraméteres polimorfizmus:}} A kódot általánosan írják meg különböző típusok számára, és alkalmazható az összes típusra, amely megfelel bizonyos, a kódban előre megadott feltételeknek. Objektumorientált környezetben sablonnak vagy generikusnak nevezik. Funkcionális programozási környezetben egyszerűen polimorfizmusnak hívják. + \item {\textbf {Altípusosság:}} A név több különböző osztály példányait jelöli, amelyeknek a függvényt deklaráló közös őse van.[3] Objektumorientált környezetben többnyire erre gondolnak, amikor polimorfizmusról beszélnek. +\end{itemize} + +\subsection{Paraméteres polimorfizmus} +A parametrikus polimorfizmus jellemzője, hogy a függvényt egyszer kell megírni, és az minden típusra egységesen fog működni. A függvény paramétereinek típusát a függvény használatakor paraméterben kell megadni, innen a paraméteres név. Szokták generikusnak is hívni, az egységes viselkedés miatt. Használata a teljes típusbiztonság megőrzésével növeli a nyelv kifejezőerejét. + +A paraméteres polimorfizmus nemcsak függvényekre, hanem adattípusokra is értelmezhető, tehát adattípusokra is lehetnek paraméteresek, más néven generikusok. A generikus típusok polimorfikus adattípusok néven is megtalálhatók. + +A parametrikus polimorfizmus nagyon gyakori a funkcionális programozásban, emiatt gyakran csak polimorfizmusnak nevezik. Az alábbi Haskell példa egy paraméteres polimorf lista adattípust mutat be, két paraméteresen polimorf függvénnyel. + +\begin{verbatim} +class List { + class Node { + T elem; + Node next; + } + Node head; + int length() { ... } +} + +List map(Func f, List xs) { + ... +} +\end{verbatim} + +Objektumorientált nyelvekben kevésbé gyakori, de legtöbbjükben szintén van lehetőség paraméteres polimorfizmusra. Ezt C++-ban és D-ben template-ek, Javában genericek biztosítják. + +\subsection{Altípusosság} +Egyes nyelvekben az altípusosság használható a polimorfizmus korlátozására. Ezekben a nyelvekben az altípusosság lehetővé teszi, hogy egy függvény egy bizonyos T típusú objektumot használjon, de ha S altípusa T-nek, akkor a függvény S típusú objektumokra is használható a Liskov-féle helyettesíti elv szerint. Az altípus jelölése néha S <: T. Megfordítva, T szupertípusa S-nek, ennek jele T :> S. Az altípusos polimorfizmus rendszerint dinamikus. + +A következő példában a kutya és a macska az állatok altípusa. A letsHear() eljárás állatot fogad, de altípusos objektumokkal is működik. + +\begin{verbatim} +abstract class Animal { + abstract String talk(); +} + +class Cat extends Animal { + String talk() { + return "Meow!"; + } +} + +class Dog extends Animal { + String talk() { + return "Woof!"; + } +} + +void letsHear(final Animal a) { + println(a.talk()); +} + +int main() { + letsHear(new Cat()); + letsHear(new Dog()); +} +\end{verbatim} + +A következő példában Number, Rational, és Integer típusok úgy, hogy Number :> Rational és Number :> Integer. Egy függvény, aminek paramétere Number, úgy működik Integer vagy Rational paraméterrel, mint Number paraméterrel. Az aktuális típus elrejthető a felhasználó elől, és objektumazonossággal férhető hozzá. Valójában, ha a Number típus absztrakt, akkor nem is lehetnek olyan objektumok, amelyek aktuális típusa Number. Lásd: absztrakt osztály, absztrakt adattípus. Ez a típushierarchia számtoronyként is ismert a Scheme programozási nyelvből, és rendszerint még több típusból áll. + +Az objektumorientált nyelvek az altípusos polimorfizmust öröklődéssel valósítják meg. Tipikus implementációkban az osztályok tartalmaznak virtuális táblát, ami hivatkozza az osztály interfészének polimorf részét megvalósító függvényeit. Minden objektum tartalmaz egy referenciát erre a táblára, amire mindig szükség van, ha valami egy polimorf függvényt hív. Ez a mechanizmus példa a: +\begin{itemize} + \item Késői kötésre, mert a virtuális függvényhívások csak a híváskor kapcsolódnak; + \item Egyszeri küldésre, mivel a virtuális függvényhívások csak az első argumentumuk virtuális tábláját veszik figyelembe, így a többi argumentum dinamikus típusa nincs figyelembe véve. +\end{itemize} + +Néhány objektumrendszer, például a Common Lisp Object System többszörös küldésre is képes, így a hívások az összes argumentumokban polimorfak lesznek. + +\end{document} \ No newline at end of file diff --git a/11. Objektumelvű programozási nyelvek/definiciok.pdf b/11. Objektumelvű programozási nyelvek/definiciok.pdf new file mode 100644 index 0000000..85667a0 Binary files /dev/null and b/11. Objektumelvű programozási nyelvek/definiciok.pdf differ diff --git a/12. Formális nyelvek és automaták/12. Formális nyelvek és automaták.pdf b/12. Formális nyelvek és automaták/12. Formális nyelvek és automaták.pdf new file mode 100644 index 0000000..9ef407b Binary files /dev/null and b/12. Formális nyelvek és automaták/12. Formális nyelvek és automaták.pdf differ diff --git a/12. Formális nyelvek és automaták/12. Formális nyelvek és automaták.tex b/12. Formális nyelvek és automaták/12. Formális nyelvek és automaták.tex new file mode 100644 index 0000000..e546494 --- /dev/null +++ b/12. Formális nyelvek és automaták/12. Formális nyelvek és automaták.tex @@ -0,0 +1,405 @@ +\documentclass[margin=0px]{article} + +\usepackage{listings} +\usepackage[utf8]{inputenc} +\usepackage{graphicx} +\usepackage{float} +\usepackage[a4paper, margin=0.7in]{geometry} +\usepackage{subcaption} +\usepackage{amsthm} +\usepackage{amssymb} +\usepackage{amsmath} +\usepackage{fancyhdr} +\usepackage{setspace} + +\onehalfspacing + +\renewcommand{\figurename}{ábra} +\newenvironment{tetel}[1]{\paragraph{#1 \\}}{} + +\pagestyle{fancy} +\lhead{\it{PTI BSc Záróvizsga tételek}} +\rhead{12. Formális nyelvek és automaták} + +\title{\textbf{{\Large ELTE IK - Programtervező Informatikus BSc} \vspace{0.2cm} \\ {\huge Záróvizsga tételek}} \vspace{0.3cm} \\ 12. Formális nyelvek és automaták} +\author{} +\date{} + +\begin{document} +\maketitle + +\begin{tetel}{Formális nyelvek és automaták} + Generatív grammatikák és a Chomsky-féle hierarchia. Grammatikák normálformái. Reguláris kifejezések. Véges automata. Veremautomata. Nyelvosztályok zártsági tulajdonságai. A reguláris és a környezetfüggetlen nyelvosztályok algoritmikus problémái. +\end{tetel} + +\section{Formális nyelvtanok és a Chomsky-féle hierarchia} +\subsection{Alapfogalmak} +\begin{description} + \item[Ábécé, szó] \hfill \\ + Szimbólumok véges nemüres halmazát ábécének nevezzük. + + Egy $V$ ábécé elemeiből képzett véges sorozatokat $V$ feletti szavaknak vagy sztringeknek nevezzük. A 0 hosszúságú sorozatot üres szónak nevezzük és + $\varepsilon$-nal jelöljük. + + A $V$ ábécé feletti szavak halmazát (beleértve az üres szót is) $V^*$-gal, a nemüres szavak halmazát $V^+$-szal jelöljük. + + \item[Konkatenáció] \hfill \\ + Az $ x = uv$ szót az $u,v \in V$ szavak konkatenációjának nevezzük. + + A konkatenáció asszociatív, de (általában) nem kommutatív. + + $V^*$ zárt a konkatenációra. Azaz: + \begin{align*} + u,v \in V^* \Rightarrow uv \in V^* + \end{align*} + Továbbá $\varepsilon$ egységelemnek tekinthető $V^*$-gal és a konkatenációval. Azaz: + \begin{align*} + u \in V^* \Rightarrow u\varepsilon \in V^* \textrm{, és }\varepsilon u \in V^* + \end{align*} + \item[Egyéb definíciók] \hfill + \begin{itemize} + \item $u,v \in V$. Az $u$ szót a $v$ részszavának nevezzük, ha $ v = xuy , \ (x,y \in V)$ teljesül. Ha még $xy\neq\varepsilon$, akkor $u$ valódi részszó. + + \item $ v = xuy \ (x,y,u,v \in V)$. Ekkor: + \begin{itemize} + \item Ha $x=\varepsilon$, akkor $u$-t a $v$ szó prefixének nevezzük + \item Ha $y=\varepsilon$, akkor $u$-t a $v$ szó szufixének nevezzük + \end{itemize} + + \item Egy $u\in V$ szó tükörképe alatt a szimbólumai fordított sorrendben való felírását értjük. (Jele: $u^{-1}$) + \end{itemize} +\end{description} +\subsection{Formális nyelvtanok} +\begin{description} + \item[Nyelv] \hfill \\ + Ha $L \subset V^*$, akkor $L$-et $V$ feletti nyelvnek tekintjük. + + Az üres nyelv (egy szót sem tartalmaz) jele: $\emptyset$ + + $L$ nyelv véges nyelv, ha véges számú szót tartalmaz, különben végtelen nyelv. + + Nyelvekre vonatkozó műveletek: + \begin{itemize} + \item $ L_1 \cup L_2 = \{u | \ u \in L_1 $ vagy $ u \in L_2\}$ : az $L_1$ és $L_2$ nyelv uniója + \item $ L_1 \cap L_2 = \{u | \ u \in L_1 $ és $ u \in L_2\}$ : az $L_1$ és $L_2$ nyelv metszete + \item $ L_1 - L_2 = \{u | \ u \in L_1 $ és $ u \notin L_2\}$ : az $L_1$ és $L_2$ nyelv különbsége + \item $\overline{L} = V^* - L$ : az $L \subseteq V^*$ komplementere + \item $L_1L_2 = \{u_1u_2 | \ u_1 \in L_1, u_2 \in L_2\}$ : az $L_1$ és $L_2$ nyelv konkatenációja\\ + Minden nyelvre fennáll: $\emptyset L = L \emptyset = \emptyset$ illetve $\{\varepsilon\}L = L\{\varepsilon\} = L$ + \item $L^i$ : az $L$ nyelv $i$-edik ($i \geq 1$) iterációja (a konkatenációra nézve), és $L^0 = \{\varepsilon\}$ + \item $ L^* = \bigcup\limits_{i\geq1} L^i$ : az $L$ nyelv iteratív lezártja + \end{itemize} + Az unió, konkatenáció és iteráció lezárása műveleteket reguláris művelteknek nevezzük. + \item[Grammatika] \hfill \\ + Nyelvek sokféle módon előállíthatók. A produkciós rendszerekkel való előállítás egyik módja a nyelvek generálása grammatikával. + + A $G$ generatív grammatikán egy $(N,T,P,S)$ négyest értünk, ahol: + \begin{itemize} + \item $N$ és $T$ diszjunkt ábécék, a nemterminális ($N$) és terminális ($T$) szimbólumok ábécéi. + \item $S\in N$ a kezdőszimbólum. + \item $P$ az $(x,y)$ rendezett párok halmaza, ahol $x,y \in (N \cup T)^*$ és $x$ legalább egy nemterminális szimbólumot tartalmaz. \\ + A $P$ halmaz elemeit átírási szabályoknak nevezzük. + \end{itemize} + Az $(x,y)$ jelölés helyett az $x \rightarrow y$ jelölést alkalmazzuk. (Ha $\rightarrow \notin (N\cup T)$ ) + \item[Levezetés] \hfill \\ + $ G = (N,T,P,S) $, és $u,v \in (N\cup T)^*$. A $v$ szó közvelenül (egy lépésben) levezethető $u$ szóból $G$-ben, ha + \begin{align*} + u = u_1xu_2, \ v = u_1yu_2 \ \textrm{és} \ x \rightarrow y \in P \quad (u_1, u_2 \in (N \cup T)^*) + \end{align*} + Ezt $ u \Longrightarrow_G v$ jelöljük. + + Azt mondjuk, hogy a $v$ szó $k \ (\geq 1)$ lépésben levezethető az $u$ szóból $G$-ben, ha + \begin{align*} + \exists u_1, ... , u_{k+1} \in (N\cup T)^*: u = u_1, v = u_{k+1} \ \textrm{és} \ u_i \Longrightarrow_G u_{i+1} \quad (1 \leq i \leq k) + \end{align*} + + A $v$ szó levezethető az $u$ szóból G-ben, ha $u=v$ vagy $\exists k \geq 1$ szám, hogy $v$ $k$ lépésben levezethető $u$-ból.\\ + Másképp: A $v$ szó levezethető az $u$ szóból G-ben (jele: $ u \Longrightarrow_G^* v $), ha $u=v$ vagy $\exists z \in (N\cup T)^*$ szó, hogy $ u \Longrightarrow_G^* z $ és $ z \Longrightarrow_G v $ + \item[Generált nyelv] \hfill \\ + $L(G)$ a $G=(N,T,P,S)$ grammatika által generált nyelv, ha: + \begin{align*} + L(G) = \{w | \ S \Longrightarrow_G^* w, w \in T^*\} + \end{align*} +\end{description} +\subsection{Chomsky-féle hierarchia} +$G = (N,T,P,S)$ generatív grammatika $i$-típusú ($i=0,1,2,3$), ha $P$ szabályhalmazára a következők teljesülnek: +\begin{description} + \item[Mondatszerkezetű grammatika (i=0)] \hfill \\ + Nincs korlátozás + \item[Környezetfüggő grammatika (i=1)] \hfill \\ + $P$ minden szabálya $u_1Au_2 \rightarrow u_1vu_2$ alakú, ahol, $A\in N$ és $ v \neq \varepsilon $, ($u_1,u_2, v \in (N \cup T)^*$). + Kivéve az $S \rightarrow \varepsilon$ szabályt (ha létezik). Ekkor $S$ nem fordul elő egyetlen szabály jobboldalán sem. + \item[Környezetfüggetlen grammatika (i=2)] \hfill \\ + $P$ minden szabálya $A \rightarrow v$ alakú, ahol, $A\in N, v \in (N \cup T)^*$. + \item[Reguláris grammatika (i=3)] \hfill \\ + $P$ minden szabálya $A \rightarrow vB$ vagy $A \rightarrow v$ alakú, ahol, $A,B\in N, v \in T^*$. +\end{description} + +\noindent +$L$ nyelv $i$-típusú, ha $i$-típusú grammatikával generálható. Az $i$-típusú nyelvek osztályát $\mathcal{L}_i$ jelöljük. + +\noindent +Az $i$-típusú nyelvosztályok a következő tulajdonságokkal rendelkeznek: +\begin{itemize} + \item $ \mathcal{L}_3 \subset \mathcal{L}_2 \subset \mathcal{L}_1 \subset \mathcal{L}_0 $ + \item Az $\mathcal{L}_i \ (i=0,1,2,3)$ nyelvosztályok mindegyike zárt a reguláris műveletekre. +\end{itemize} +\section{Automaták} +Formális nyelvek megadása nemcsak generatív, hanem felismerő eszközökkel is lehetséges, azaz olyan számítási eszközök segítségével, amelyek szavak feldolgozására és azonosítására alkalmasak. +Ilyen eszköz például az automata, amely egy szó, mint input hatására kétféleképpen viselkedhet: vagy elfogadja, vagy elutasítja. +\subsection{Véges Automata} +\begin{description} + \item[Definíció] \hfill \\ + A véges automata egy rendezett ötös, + \[A=(Q,T,\delta,q_0, F)\] + ahol: + \begin{itemize} + \item Q - állapotok véges nemüres halmaza + \item T - input szimbólumok ábécéje + \item $\delta : Q \times T \rightarrow Q$ - állapot-átementi függvény + \item $q_0 \in Q$ - kezdőállapot + \item $F \subseteq Q$ - elfogadó állapotok halmaza + \end{itemize} + + Működés:\\ + A véges automata diszkrét időintervallumokban végrehajtott lépések sorozata által működik. Minden egyes lépés során az automata elolvassa a következő input szimbólumot és átmegy egy olyan állapotba, amelyet az állapotátmeneti függvény meghatároz (az aktuális állapot és input szimbólum alapján). + + Kezdetben az $A$ véges automata a $q_0$ kezdőállapotban van és az olvasófej az input szalagon levő $u \in T^*$ szó első betűjét dolgozza fel. Ezután a véges automata lépések sorozatát végrehajtva elolvassa az input $u$ szót; betűről betűre haladva olvas és új állapotba kerül. + + Miután az $u$ input szó utolsó betűjét is elolvasta a véges automata, vagy $q \in F,$ azaz elfogadó állapotba kerül, és akkor az $u$ szót az automata elfogadja, vagy az új állapot nem lesz eleme $F$-nek, és ekkor az automata a szót nem fogadja el. + + + \item[VDA - Véges determinisztikus automata] \hfill \\ + A $\delta$ függvény egyértékű, ezért minden egyes $(q, a)$ párra, ahol $(q, a) \in Q \times T$ egyetlen olyan $s$ állapot létezik, amelyre $\delta(q, a) = s$ teljesül. Ezért ezt a véges automatát determinisztikusnak nevezzük. + \item[VNDA - Véges nemdeterminisztikus automata] \hfill \\ + Ha többértékű állapot-átmeneti függvényt is megengedünk, azaz $\delta : Q \times T \rightarrow 2^Q$, akkor nemdeterminisztikus véges automatáról beszélünk. (Ebben az esetben aktuális állapotnak egy állapothalmaz valamely elemét, mintsem egyetlen állapotot tekinthetünk.) + + Ez azt jelenti, hogy a kezdeti állapot helyettesíthető egy $Q_0 \subseteq Q$ kezdőállapot halmazzal. + (És az is előfordulhat, hogy egy a input szimbólum esetén $\delta(q, a)$ üres az aktuális állapotok mindegyikére.) + \item[Tulajdonságok] \hfill \\ + Az állapot-átmeneteket + \[qa \rightarrow p\] + alakú szabályok formájában is írhatjuk $p \in \delta(q, a) $ esetén. Jelöljük $M_\delta$-val az $A = (Q, T, \delta,Q_0, F)$ nemdeterminisztikus véges automata $\delta$ állapot-átmenet függvénye által az előbbi módon származó szabályok halmazát. + + Ha minden egyes $(q, a)$ párra egyetlen $qa \rightarrow p$ szabály van $M_\delta$-ban, akkor a véges automata determinisztikus, egyébként nemdeterminisztikus. + + \begin{itemize} + \item Közvetlen redukció: \\ + Legyen $A = (Q, T, \delta, q_0, F)$ egy véges automata és legyenek $u, v \in QT^*$ szavak. Azt mondjuk, hogy az $A$ automata az $u$ szót a $v$ szóra redukálja egy lépésben/közvetlenül. Ha van olyan $qa \rightarrow p$ szabály $M_\delta$-ban, és van olyan $w \in T^*$ szó, amelyre $u = qaw$ és $v = pw$ teljesül. + + \item Redukció:\\ + Az $A = (Q, T, \delta, q_0, F)$ véges automata az $u \in QT^*$ szót a $v \in QT^*$ szóra redukálja $(u \Longrightarrow_A^* v)$, ha $u = v$, vagy $ \exists z \in QT^*$, amelyre $u \Longrightarrow_A^* z$ és $z \Longrightarrow_A v$ teljesül. + + \item Az automata által elfogadott nyelv:\\ + Az $A = (Q, T, \delta, q_0, F)$ véges automata által elfogadott/felismert nyelv alatt az \[ L(A) = \{u \in T^* | \ q_0u \Longrightarrow_A^* p, \quad q_0 \in Q_0 \textrm{ és } p \in F\} \] szavak halmazát értjük. (Az üres szó, akkor és csak akkor van benne az automata által elfogadott $L(A)$ nyelvben, ha $Q_0 \cap F \neq \emptyset$). + + \item Tétel:\\ + Minden $A$ nemdeterminisztikus véges automatához meg tudunk adni egy 3-típusú $G$ grammatikát úgy, hogy $L(G) = L(A)$ teljesül. + + \item Tétel: \\ + Minden 3-típusú G grammatikához meg tudunk adni egy $A$ véges automatát úgy, hogy $L(A) = L(G)$ teljesül. \\ + + + Ezek után fenáll a kérdés: Létezik-e olyan reguláris nyelv, amely VNDA-val felismerhető, de nem ismerhető fel VDA-val? \\ + Válasz: Nincs. + + \item Tétel:\\ + Minden $A = (Q, T, \delta,Q_0, F)$ VNDA-hoz meg tudunk konstruálni egy $A' = (Q', T, \delta', q_0', F')$ VDA-t úgy, hogy $L(A) = L(A')$ teljesül. + \end{itemize} +\end{description} +\subsection{Veremautomata} +\begin{description} + \item[Definíció] \hfill \\ + A veremautomata egy rendezett hetes + \[A = (Z,Q, T, \delta, z_0, q_0, F)\] + ahol + \begin{itemize} + \item Z - a veremszimbólumok véges halmaza, + \item Q - az állapotok véges halmaza, + \item T - az inputszimbólumok véges halmaza, + \item $\delta : Z \times Q \times (T \cup \{\varepsilon\}) \rightarrow 2^{Z^* \times Q}$ - átmeneti függvény + \item $z_0 \in Z $ - a kezdeti veremszimbólum, + \item $q_0 \in Q $ - a kezdeti állapot, + \item $F \subseteq Q$ - az elfogadó állapotok halmaza + \end{itemize} + + A veremautomata konfigurációja alatt egy $uq$ alakú szót értünk, ahol $u \in Z^*$ a verem aktuális tartalma és $q \in Q$ az aktuális állapot. \\ + A kezdeti konfiguráció $z_0q_0$. + + Működés: \\ + Tegyük fel, hogy az $A$ veremautomata olvasófeje az $a$ inputszimbólumon áll, a veremautomata $q$ állapotban van, valamint a verem tetején levő szimbólum $z$. Legyen $ \delta(z, q, a) = {(u_1, r_1), . . . , (u_n, r_n)}$, ahol $u_i \in Z^*$ és $r_i \in Q, 1 \leq i \leq n$. Ekkor $A$ következő állapota valamely $r_i$ lesz és egyidejűleg $z$-t helyettesíti az $u_i$ szóval, továbbá az olvasófej egy cellával jobbra lép az input szalagon.\\ + Ha $\delta(z, q, \varepsilon)$ nem üres, akkor ún. $\varepsilon$-átmenet hajtható végre. + + Ha az input szalag a $w \in T^*$ szót tartalmazza és a $z_0q_0$ kezdeti konfigurációból kiindulva a lépések sorozatát végrehajtva az $A$ veremautomata egy $up$ konfigurációba ér, ahol $p$ elfogadó állapot, akkor azt mondjuk, hogy $A$ elfogadta a $w$ szó. + + \item[Tulajdonságok] \hfill + \begin{itemize} + \item Közvetlen redukció: \\ + $\alpha, \beta \in Z^*QT^*$\\ + Az $A$ veremautomata az $\alpha $ szót a $\beta$ szóra redukálja egy lépésben ($\alpha \Longrightarrow_A \beta$), ha: + \[\exists z \in Z, \ p,q \in Q, \ a \in T \cup \{\varepsilon\}, \ r,u \in Z^* \textrm{ és } w\in T^*\] + hogy: + \[(u,p) \in \delta(z,q,a) \textrm{ és } \alpha = rzqaw \textrm{ és } \beta = rupw\] + \item Redukció: \\ + Az A veremautomata az $\alpha$ szót a $\beta$ szóra redukálja ($\alpha \Longrightarrow_A^* \beta$), ha vagy $\alpha = \beta$, vagy + $ \exists \gamma_1,...,\gamma_n \in Z^*QT^*$ szavakból álló véges sorozat, hogy $\alpha = \gamma_1, \ \beta = \gamma_n, \quad \textrm{ és } \quad \\ {\gamma_i \Longrightarrow_A \gamma_{i+1} \quad (i=1,...,n-1)}$ + \item A veremautomata által elfogadott nyelv: \\ + Az A veremautomata által (elfogadó állapottal) elfogadott nyelv: + \[L(A) = \{ w \in T^* | \ z_0q_0w \Longrightarrow_A^* up, \textrm{ ahol } u \in Z^*, p \in F \} \] + \item Determinizmus: \\ + A $\delta$ leképezést szabályok formájában is megadhatjuk. Az így nyert szabályhalmazt $M_\delta$-val jelöljük. Tehát + \begin{enumerate} + \item $zqa \rightarrow up \in M_\delta$ ha $(u, p) \in \delta(z, q, a)$ + \item $zq \rightarrow up \in M_\delta$ ha $(u, p) \in \delta(z, q, \varepsilon)$ + \end{enumerate} + + Az $A = (Z,Q, T,\delta, z_0, q_0, F)$ veremautomatát determinisztikusnak mondjuk, ha minden $(z, q) \in Z \times Q$ pár esetén: + \begin{enumerate} + \item $\forall a \in T: |\delta(z, q, a)| = 1$ és $\delta(z, q, \varepsilon) = \emptyset$ + + vagy + \item $|(z, q, \varepsilon)| = 1 $ és $\forall a \in T: \delta(z, q, a) = \emptyset$ + \end{enumerate} + \item Üres veremmel elfogadott nyelv: \\ + Az $N(A)$ nyelvet az $A$ veremautomata üres veremmel fogadja el, ha + \[ N(A) = \{w \in T^* | \ z_0q_0w \Longrightarrow_A^* p, \textrm{ ahol } p \in Q \} \] + \item Tétel: \\ + Bármely $G$ környezetfüggetlen grammatikához meg tudunk adni egy olyan $A$ veremautomatát, amelyre $L(A) = L(G)$ teljesül. + \item Tétel: \\ + Minden $A$ veremautomatához meg tudunk adni egy környezetfüggetlen $G$ grammatikát úgy, hogy $L(G) = N(A)$ teljesül. + \end{itemize} +\end{description} +\section{Reguláris nyelvek tulajdonságai és alkalmazásai} +\subsection{3-típusú grammatikák normálformája} +Minden 3-típusú, azaz reguláris nyelv generálható egy olyan grammatikával, amelynek szabályai: +\begin{itemize} + \item $ X \rightarrow aY$, ahol $X,Y \in N$ és $a \in T$ + \item $X \rightarrow \varepsilon$, ahol $X \in N$ +\end{itemize} +\subsection{Reguláris kifejzések} +\begin{description} + \item[Motiváció] \hfill \\ + Ismeretes, hogy minden véges nyelv reguláris. Tudjuk továbbá, hogy az $\mathcal{L}_3$ nyelvosztály (a reguláris nyelvek osztálya) zárt az unió, a konkatenáció és az iteráció lezártja műveletekre nézve. + + Következésképpen, kiindulva véges számú véges nyelvből és az előzőekben felsorolt, ún. reguláris műveleteket véges sokszor alkalmazva reguláris nyelvet kapunk. + + Kérdés az, hogy vajon ezzel az eljárással minden reguláris nyelvet + elő tudunk-e állítani, azaz, ez a módszer elégséges-e az $\mathcal{L}_3$ nyelvosztály leírására? + \item[Definíció] \hfill \\ + Legyenek $V$ és $V' = \{\varepsilon, \cdot, +, *, (, )\}$ diszjunkt ábécék. A $V$ ábécé feletti reguláris kifejezéseket rekurzív módon a következőképpen definiáljuk: + \begin{enumerate} + \item $\varepsilon$ reguláris kifejezés $V$ felett. + \item Minden $a \in V$ reguláris kifejezés $V$ felett. + \item Ha R reguláris kifejezés V felett, akkor $(R)^*$ is reguláris kifejezés $V$ felett. [iteratív lezárás] + \item Ha $Q$ és $R$ reguláris kifejezések $V$ felett, akkor $(Q) \cdot (R)$ [konkatenáció] és $(Q) + (R)$ [unió] is reguláris kifejezés $V$ felett. + \end{enumerate} + + \textit{Megjegyzés: Minden reguláris kifejezés jelöl (meghatároz) valamely reguláris nyelvet. (Pl.: $\varepsilon$ a $\{\varepsilon\}$ nyelvet, $a+b$ az $\{a\} \cup \{b\} = \{a,b\}$ és $a\cdot b$ az $\{a\}\{b\} = \{ab\}$ nyelvet.) A reguláris kifejezés a szintaxis, az, hogy hogyan értelmezzük, a szemantika.} + \item[Axiómák]\hfill \\ + $P,Q,R$ reguláris kifejezések. Ekkor fennállnak a következő tulajdonságok: + \begin{itemize} + \item Asszociativitás: + \[P+(Q+R) = (P+Q)+R\] + \[P\cdot(Q\cdot R) = (P\cdot Q)\cdot R\] + \item Kommutativitás: + \[P+Q = Q+P\] + \item Disztributivitás: + \[P\cdot (Q+R) = P\cdot Q + P\cdot R\] + \[(P+Q)\cdot R = P\cdot R + Q\cdot R\] + \item Egységelem: + \[\varepsilon\cdot P = P\cdot\varepsilon = P\] + \[P^* = \varepsilon + P \cdot P^*\] + \[P^* = (\varepsilon+P)^*\] + \end{itemize} + + A fenti axiómák azonban még önmagukban nem elegendőek az összes reguláris kifejezés előállítására (helyettesítés segítségével). Szükség van még az alábbi inferencia szabályra: + \[P=R+P\cdot Q \quad \land \quad \varepsilon \notin Q \quad \Longrightarrow \quad P = R\cdot Q^*\] + + Vegyük még hozzá az $\emptyset$ szimbólumot a reguláris kifejezések halmazához, amely az üres nyelvet jelöli. (Ebben az esetben nincs szükségünk az $\varepsilon$ szimbólumra, mivel $\emptyset^* = \{\varepsilon\}$). Így, a definícióban helyettesíthetjük az $\varepsilon$ szimbólumot az $\emptyset$ szimbólummal. Ekkor helyettesítjük $\varepsilon$-t a megelőző axióma rendszerben $(\emptyset)^*$-gal és még egy további + axiómát tekintünk: + \[\emptyset\cdot P = P\cdot\emptyset = \emptyset\] + A fenti szabályok elégségesek ahhoz, hogy levezessünk minden érvényes egyenlőséget + reguláris kifejezések között. + \item[Reguláris kifejezések és reguláris nyelvek] \hfill \\ + Minden reguláris kifejezés egy reguláris (3-típusú) nyelvet jelöl, és megfordítva, minden reguláris nyelvhez megadható egy, ezen nyelvet jelölő reguláris kifejezés.\\ (Ezzel választ adtunk a motivációban feltett kérdésre.) +\end{description} +\subsection{Lineáris grammatikák és nyelvek} +\begin{description} + \item[Definíció] \hfill \\ + Egy $G=(N,T,P,S)$ környezetfüggetlen grammatikát lineárisnak nevezünk, ha minden szabálya: + \begin{enumerate} + \item $A\rightarrow u, \quad A \in N, u \in T^*$ + \item $A\rightarrow u_1Bu_2, \quad A,B\in N, u_1,u_2 \in T^*$ + \end{enumerate} + Továbbá $G$-t bal-lineárisnak, illetve jobb-lineárisnak mondjuk, ha $u_1 = \varepsilon$, illetve $u_2 = \varepsilon$ minden 2. alakú szabályra. + + Egy $L$ nyelvet lineárisnak, bal-lineárisnak, illetve jobb-lineárisnak mondunk, + ha van olyan $G$ lineáris, bal-lineáris, illetve jobb-lineáris grammatika, + amelyre $L = L(G)$ teljesül. + \item[Lineáris és reguláris grammatikák, nyelvek] \hfill \\ + A jobb-lineáris grammatikák azonosak a reguláris grammatikákkal (3-típusúak). + + Tétel: \\ + Minden bal-lineáris grammatika reguláris (3-típusú) nyelvet generál. +\end{description} +\section{Környezetfüggetlen nyelvek tulajdonságai és elemzésük} +\subsection{Környezetfüggetlen grammatikák normálformái} +Környezetfüggetlen grammatikák normálformái olyan grammatikai transzformációval előállított grammatikák, melyek: +\begin{itemize} + \item bizonyos szintaktikai feltételeknek/tulajdonságoknak tesznek eleget + \item (általában) valamilyen szempontból egyszerűbbek, mint az eredeti grammatikák + \item ugyanazt a nyelvet generálják (így ugyanazon típusba tartoznak) +\end{itemize} +Tétel:\\ +Minden $G = (N, T, P, S)$ környezetfüggetlen grammatikához meg tudunk konstruálni egy vele ekvivalens $G' = (N', T, P', S')$ környezetfüggetlen grammatikát úgy, hogy: $G'$ minden szabályának jobboldala nemüres szó [kivéve azt az esetet, mikor $\varepsilon \in L(G)$, ekkor $S' \rightarrow \varepsilon$ az egyetlen szabály, melynek jobboldala az üres szó és ekkor $S'$ nem fordul elő $G'$ egyetlen szabályának jobboldalán sem.] +\begin{description} + \item[$\varepsilon$-mentes grammatika] \hfill \\ + A $G$ grammatika $\varepsilon$-mentes, ha egyetlen szabályának jobboldala sem az üres szó. + + Tétel:\\ + Minden környezetfüggetlen $G$ grammatikához meg tudunk konstruálni egy $G'$ $\varepsilon$-mentes környezetfüggetlen grammatikát, amelyre $L(G') = L(G) - \{\varepsilon\}$ teljesül. + \item[Chomsky normálforma] \hfill \\ + A $G = (N, T, P, S)$ környezetfüggetlen grammatikát Chomsky-normálformájúnak mondjuk, ha minden egyes szabálya: + \begin{itemize} + \item $X \rightarrow a$, ahol $X \in N, a \in T$ + \item $X \rightarrow YZ$, ahol $X,Y,Z \in N$ + \end{itemize} + Tétel:\\ + Minden $\varepsilon$-mentes $G=(N,T,P,S)$ környezetfüggetlen grammatikához meg tudunk konstruálni egy vele ekvivalens $G' = (N', T, P', S)$ Chomsky-normálformájú környezetfüggetlen grammatikát. + + Tétel (az előző következménye):\\ + Minden $G$ környezetfüggetlen grammatika esetében eldönthető, hogy egy $u$ szó benne van-e $G$ grammatika által generált nyelvben. + \item[Redukált grammatika] \hfill + \begin{itemize} + \item A környezetfüggetlen grammatika egy nemterminálisát inaktívnak/nem aktívnak nevezzük, ha nem vezethető le belőle terminális szó. + \item A környezetfüggetlen grammatika egy nemterminálisát nem elérhetőnek nevezzük, ha nem fordul elő egyetlen olyan szóban sem, amely a kezdőszimbólumból levezethető. + \item Egy nemterminálist nem hasznosnak mondunk, ha vagy inaktív, és/vagy nem elérhető. + \item Az, hogy egy $A$ nemterminális elérhető-e vagy aktív-e, az eldönthető. + \item Egy környezetfüggetlen grammatika redukált, ha minden nemterminálisa aktív és elérhető. + \end{itemize} + Tétel:\\ + Minden környezetfüggetlen grammatikához meg tudunk konstruálni egy vele ekvivalens redukált környezetfüggetlen grammatikát. + +\end{description} +\subsection{Levezetési fa} +A környezetfüggetlen grammatikák levezetéseit fákkal is jellemezhetjük. A levezetési fa egy szó előállításának lehetőségeiről ad információkat. A levezetési fa egy irányított gráf, amely speciális tulajdonságoknak tesz eleget: +\begin{itemize} + \item A gyökér cimkéje: $S$ + \item A többi csúcs cimkéje ($N\cup T$) valamely eleme +\end{itemize} +A levezetési fa nem minden esetben adja meg a levezetés során alkalmazott szabályok sorrendjét. Két levezetés lényegében azonos, ha csak a szabályok alkalmazásának sorrendjében különbözik. + +Egy környezetfüggetlen grammatika minden levezetési fája egy egyértelmű (egyetlen) legbaloldalibb levezetést határoz meg. A legbaloldalibb levezetés során minden levezetési lépésben a legbaloldalibb nemterminálist kell helyettesítenünk. +\\\\ +Tétel:\\ +Minden környezetfüggetlen grammatikáról eldönthető, hogy az általa generált nyelv az üres nyelv-e vagy sem. +\subsection{Bar-Hillel Lemma} +Minden $L$ környezetfüggetlen nyelvhez meg tudunk adni két $p$ és $q$ természetes számot úgy, hogy minden olyan szó $L$-ben, amely hosszabb, mint $p$ +\[uxwyz\] +alakú, ahol $|xwy| \leq q$, $xy \neq \varepsilon$ , és minden +\[ux^iwy^iv\] +szó is benne van az $L$ nyelvben minden $i \geq 0$ egész számra ($u,x,w,y,v \in T^*$). +\\\\ +Tétel:\\ +Eldönthető, hogy egy környezetfüggetlen grammatika végtelen nyelvet generál-e vagy sem. +\end{document} \ No newline at end of file diff --git a/13. Számításelmélet (és Logika)/13. Számításelmélet.pdf b/13. Számításelmélet (és Logika)/13. Számításelmélet.pdf new file mode 100644 index 0000000..6caa62c Binary files /dev/null and b/13. Számításelmélet (és Logika)/13. Számításelmélet.pdf differ diff --git a/13. Számításelmélet (és Logika)/13. Számításelmélet.tex b/13. Számításelmélet (és Logika)/13. Számításelmélet.tex new file mode 100644 index 0000000..8687260 --- /dev/null +++ b/13. Számításelmélet (és Logika)/13. Számításelmélet.tex @@ -0,0 +1,518 @@ +\documentclass[margin=0px]{article} + +\usepackage{listings} +\usepackage[utf8]{inputenc} +\usepackage{graphicx} +\usepackage{float} +\usepackage[a4paper, margin=0.7in]{geometry} +\usepackage{amsthm} +\usepackage{amssymb} +\usepackage{fancyhdr} +\usepackage{setspace} + +\onehalfspacing + +\makeatletter +\renewcommand\paragraph{% + \@startsection{paragraph}{4}{0mm}% + {-\baselineskip}% + {.5\baselineskip}% + {\normalfont\normalsize\bfseries}} +\makeatother + +\renewcommand{\figurename}{ábra} + +\newenvironment{tetel}[1]{\paragraph{#1 \\}}{} + +\pagestyle{fancy} +\lhead{\it{PTI BSc Záróvizsga tételek}} +\rhead{13. Számításelmélet} + +\title{\textbf{{\Large ELTE IK - Programtervező Informatikus BSc} \vspace{0.2cm} \\ {\huge Záróvizsga tételek}} \vspace{0.3cm} \\ 13. Számításelmélet} +\author{} +\date{} + +\begin{document} +\maketitle + +\begin{tetel}{Számításelmélet} + A Turing gép és a Church-Turing tézis. Turing gépek variánsok: többszalagos, nemdeterminisztikus, számoló, offline. Rekurzív és rekurzívan felsorolható nyelvek. Eldönthetetlen problémák. Idő- és tárbonyolultsági osztályok: P, NP, PSPACE. NP-teljes problémák. +\end{tetel} + +\section{Kiszámíthatóság} + +\subsubsection{Algoritmusmodellek} + +\begin{itemize} + \item \textbf{Gödel}: rekurzív függvények (primitív rekurzív függvények 1931-ben, majd általánosabb 1934-ben) + + \item \textbf{Church}: $\lambda$-kalkulus, $\lambda$-definiálható függvények: ekvivalensek a rekurzív függvényekkel (bizonyított) + + \item \textbf{Turing}: Turing-gép (1936), a $\lambda$-definiálható és a Turing-géppel kiszámítható függvények megegyeznek (bizonyított) + +\end{itemize} + +\noindent \textbf{Church-Turing tézis}: A kiszámíthatóság különböző matematikai modelljei mind az effektíven +kiszámítható függvények osztályát definiálják. + +\subsubsection{Fogalmak} + +Kiszámítási problémának nevezünk egy olyan, a matematika nyelvén megfogalmazott +kérdést, amire egy algoritmussal szeretnénk megadni a választ. A +gyakorlati élet szinte minden problémájához rendelhető, megfelelő absztrakciót +használva, egy kiszámítási probléma.\\ + +\noindent Egy problémát a hozzá tartozó konkrét bementettel együtt a probléma egy +példányának nevezzük.\\ + +Speciális kiszámítási probléma az eldöntési probléma. Ilyenkor a problémával +kapcsolatos kérdés egy eldöntendő kérdés, tehát a probléma egy példányára a +válasz "igen" vagy "nem" lesz.\\ + +Egy kiszámítási probléma reprezentálható egy $f : A \to B$ függvénnyel. Az $A$ +halmaz tartalmazza a probléma egyes bemeneteit, jellemzően egy megfelelő ábécé +feletti szóban elkódolva, míg a $B$ halmaz tartalmazza a bemenetekre adott +válaszokat, szintén valamely alkalmas ábécé feletti szóban elkódolva. Értelemszerűen, +ha eldöntési problémáról van szó, akkor az $f$ értékkészlete, vagyis a $B$ +egy két elemű halmaz: $\left\{igen, nem\right\}$, $\left\{1, 0\right\}$, stb.\\ + +\noindent \textbf{Kiszámítható függvény}: Egy $f : A \to B$ függvényt \textit{kiszámíthatónak} +nevezünk, ha minden $x \in A$ elemre az $f(x) \in B$ függvényérték kiszámítható valamilyen +algoritmikus modellel.\\ + +\noindent \textbf{Megoldható, eldönthető probléma}: Egy kiszámítási probléma \textit{megoldható} +(eldöntési probléma esetén azt mondjuk, hogy \textit{eldönthető}), ha az általa meghatározott +függvény kiszámítható.\\ + +\noindent \textbf{Algoritmusok időigénye}: Legyenek $f,g: \mathbb{N} \to \mathbb{N}$ függvények, ahol +$\mathbb{N}$ a természetes számok halmaza. Azt mondjuk, hogy $f$ legfeljebb olyan gyorsan nő, mint $g$ +(jelölése: $f(n) = \mathcal{O}(g(n))$), ha $\exists c>0$ és $n_{0} \in \mathbb{N}$, hogy +$f(n) \leq c * g(n) \ \forall n \geq n_{0}$. Az $f(n) = \Omega(g(n))$ jelöli azt, hogy $g(n) = \mathcal{O}(f(n))$ +teljesül és $f(n) = \Theta(g(n))$ jelöli azt, hogy $f(n) = \mathcal{O}(g(n))$ és $f(n) = \Omega(g(n))$ is teljesül.\\ + +\noindent \textbf{Példa}: $3n^{3} + 5n^{2} + 6 = \mathcal{O}(n^{3})$, $n^{k} = \mathcal{O}(2^{n}) \ \forall k \geq 0$, stb.\\ + +\noindent \textbf{Tétel}: Minden polinomiális függvény lassabban nő, mint bármely exponenciális függvény, +azaz minden $p(n)$ polinomhoz és $c>0$-hoz $\exists n_{0}$ egész szám, hogy $\forall n \geq n_{0}$ esetén $p(n) \leq 2^{cn}$\\ + +\noindent \textbf{Kiszámítási probléma megfeleltetése eldöntési problémának}: Tekintsünk egy $P$ kiszámítási problémát +és legyen $f: A \to B$ a $P$ által meghatározott függvény. Ekkor megadható $P$-hez egy $P'$ eldöntési probléma úgy, hogy +$P'$ pontosan akkor eldönthető, ha $P$ kiszámítható. Állítsuk párba ugyanis minden $a \in A$ elemre az $a$ és $f(a)$ elemeket, +és kódoljuk el az így kapott párokat egy-egy szóban. Ezek után legyen $P'$ az így kapott szavakból képzett formális nyelv. +Nyilvánvaló, hogy ha minden $a \in A$ és $b \in B$ elemre az $(a,b) \in P'$ tartalmazás eldönthető (azaz $P'$ eldönthető), akkor +$P$ kiszámítható és fordítva. +E megfeleltetés miatt a továbbiakban jellemzően eldöntési problémákkal foglalkozunk. + +\section{Turing-gépek} + +Hasonlóan a véges automatához vagy a veremautomatához, a Turing-gép is +egy véges sok állapottal rendelkező eszköz. A Turing-gép egy két irányban +végtelen szalagon dolgozik. A szalag cellákra van osztva, tulajdonképpen ez +a gép (korlátlan) memóriája. Kezdetben a szalagon csak a bemenő szó van, +minden cellán egy betű. A szalag többi cellája egy úgynevezett blank vagy +szóköz ($\sqcup$) szimbólumokkal van feltöltve. Kezdetben a gép úgynevezett író-olvasó +feje a bemenő szó első betűjén áll és a gép a kezdőállapotában van. +A gép az író-olvasó fejet tetszőlegesen képes mozgatni a szalagon. Képes továbbá +a fej pozíciójában a szalag tartalmát kiolvasni és átírni. A gépnek van két +kitüntetett állapota, a $q_{i}$ és a $q_{n}$ állapotok. Ha ezekbe az állapotokba kerül, +akkor rendre elfogadja illetve elutasítja a bemenő szót. +Formálisan a Turing-gépet a következő módon definiáljuk.\\ + +\noindent \textbf{A Turing-gép formális definíciója}: A Turing-gép egy olyan +$M = (Q, \Sigma, \Gamma, \delta, q_{0}, q_{i}, q_{n})$ rendszer, ahol: + +\begin{itemize} + + \item $Q$ az állapotok véges, nem üres halmaza, + + \item $q_{0}, q_{i}, q_{n} \in Q$, $q_{0}$ a kezdőállapot, $q_{i}$ az elfogadó állapot, + $q_{n}$ pedig az elutasító állapot, + + \item $\Sigma$ és $\Gamma$ ábécék, a bemenő jelek és a szalagszimbólumok ábécéje úgy, hogy + $\Sigma \subseteq \Gamma$ és $\Gamma - \Sigma$ tartalmaz egy speciális $\sqcup$ szimbólumot, + + \item $\delta : (Q - \left\{q_{i},q_{n}\right\}) \times \Gamma \to Q \times \Gamma \times \left\{L, R, S\right\}$ + az átmenetfüggvény. + +\end{itemize} + +Úgy mint a veremautomaták esetében, egy $M$ Turing-gép működésének fázisait is konfigurációkkal írhatjuk le.\\ + +\noindent \textbf{Turing-gép konfigurációja}: Az $M$ Turing-gép konfigurációja egy olyan $uqv$ szó, ahol +$q \in Q$ és $u, v \in \Gamma^{*}$, $v \not = \varepsilon$. Ez a konfiguráció az $M$ azon állapotát tükrözi +amikor a szalag tartalma $uv$ ($uv$ előtt és után a szalagon már csak $\sqcup$ van), a gép a $q$ állapotban van, +és az író-olvasó fej a $v$ első betűjére mutat. $M$ összes konfigurációjának halmazát $\mathcal{C}_{M}$-el jelöljük.\\ + +\noindent \textbf{Turing-gép kezdőkonfigurációja}: $M$ kezdőkonfigurációja egy olyan $q_{0}u\sqcup$ szó, ahol +$u$ csak $\Sigma$-beli betűket tartalmaz.\\ + +\noindent \textbf{Turing-gép konfigurációátmenete}: $M$ konfigurációátmenete egy olyan +$\vdash \subseteq \mathcal{C}_{M} \times \mathcal{C}_{M}$ reláció, amit a következőképpen definiálunk. +Legyen $uqav$ egy konfiguráció, ahol $a \in \Gamma$ és $u, v \in \Gamma^{*}$. A következő három esetet +különböztetjük meg: + +\begin{enumerate} + + \item Ha $\delta(q,a) = (r, b, S)$, akkor $uqav \vdash urbv$. + + \item Ha $\delta(q,a) = (r, b, R)$, akkor $uqav \vdash ubrv'$, ahol $v' = v$, ha $v \not = \varepsilon$, különben + $v' = \sqcup$. + + \item Ha $\delta(q,a) = (r, b, L)$, akkor $uqav \vdash u'rcbv$, ahol $u'c = u$ valamely $u' \in \Gamma^{*}$-ra + és $c \in \Gamma$-ra, ha $u \not = \varepsilon$, egyébként pedig $u' = \varepsilon$, $c = \sqcup$. + +\end{enumerate} + +Azt mondjuk, hogy $M$ véges sok lépésben eljut a $C$ konfigurációból a $C'$ konfigurációba (jele $C \vdash^{*} C'$), +ha létezik olyan $n \geq 0$ és $C_{1}, ... C_{n}$ konfigurációsorozat, hogy $C_{1} = C$, $C_{n} = C'$ és minden +$1 \leq i < n$-re $C_{i} \vdash C_{i+1}$. + +Ha $q \in \left\{q_{i}, q_{n}\right\}$, akkor azt mondjuk, hogy az $uqv$ konfiguráció egy megállási +konfiguráció. Továbbá, $q = q_{i}$ esetében elfogadó, míg $q = q_{n}$ esetében elutasító +konfigurációról beszélünk.\\ + +\noindent \textbf{Turing-gép által felismert nyelv}: Az $M$ Turing-gép által felismert nyelv (jelölése $L(M)$) +azoknak az $u \in \Sigma^{*}$ szavaknak a halmaza, melyekre igaz, hogy $q_{0}u\sqcup \vdash^{*} xq_{i}y$ +valamely $x,y \in \Gamma^{*}$, $y \not = \varepsilon$ szavakra. + +\begin{figure}[H] + \centering + \includegraphics[width=0.6\linewidth]{img/turinggep_pelda} + \caption{Egy, az $L = \left\{u\#u \ | \ u \in \left\{0,1\right\}^{+}\right\}$ felismerő Turing-gép.} + \label{fig:turinggep_pelda} +\end{figure} + +\noindent \textbf{Turing-gépek ekvivalenciája}: Két Turing-gépet ekvivalensnek nevezünk, ha ugyanazt a nyelvet ismerik fel.\\ + +\noindent \textbf{Turing-felismerhető nyelv, rekurzívan felismerhető nyelvek osztálya}: +Egy $L \subseteq \Sigma^{*}$ nyelv Turing-felismerhető, ha $L = L(M)$ valamely $M$ Turing-gépre. +A Turing-felismerhető nyelveket szokás \textit{rekurzívan felsorolhatónak} is nevezni. +A rekurzívan felsorolható nyelvek osztályát $RE$-vel jelöljük.\\ + +\noindent \textbf{Turing-eldönthető nyelv, rekurzív nyelvek osztálya}: +Egy $L \subseteq \Sigma^{*}$ nyelv Turing-eldönthető, ha létezik olyan Turing-gép, +amely minden bemeneten megállási konfigurációba jut és felismeri $L$-et. +A Turing-felismerhető nyelveket szokás \textit{rekurzívnak} is nevezni. +A rekurzív nyelvek osztályát $R$-rel jelöljük.\\ + +\noindent \textbf{Turing-gép futási ideje, időigénye}: +Tekintsünk egy $M = (Q, \Sigma, \Gamma, \delta, q_{0}, q_{i}, q_{n})$ Turing-gépet és annak egy +$u \in \Sigma^{*}$ bemenő szavát. Azt mondjuk, hogy $M$ futási ideje (időigénye) az $u$ szón $n$ ($n \geq 0$), +ha $M$ a $q_{0}u\sqcup$ kezdőkonfigurációból $n$ lépésben el tud jutni egy megállási konfigurációba. Ha nincs ilyen +szám, akkor $M$ futási ideje az $u$ szón végtelen. + +Legyen $f : \mathbb{N} \to \mathbb{N}$ egy függvény. Azt mondjuk, hogy $M$ időigénye $f(n)$ (vagy azt, hogy $M$ +egy $f(n)$ időkorlátos gép), ha minden $u \in \Sigma^{*}$ input szóra $M$ időigénye az $u$ szón legfeljebb $f(l(u))$. + +\subsubsection{Többszalagos Turing-gépek} + +A többszalagos Turing-gépek, értelemszerűen, egynél több szalaggal rendelkeznek. +Mindegyik szalaghoz tartozik egy-egy író-olvasó fej, melyek egymástól +függetlenül képesek mozogni a szalagon.\\ + +\noindent \textbf{Többszalagos Turing-gép definíciója}: Legyen $k > 1$. Egy $k$-szalagos Turing-gép egy olyan +$M = (Q, \Sigma, \Gamma, \delta, q_{0}, q_{i}, q_{n})$ rendszer, ahol a komponensek a $\delta$ kivételével +megegyeznek az egyszalagos Turing-gép komponenseivel, $\delta$ pedig a következőképpen adódik. +$\delta : (Q - \left\{q_{i},q_{n}\right\}) \times \Gamma^{k} \to Q \times \Gamma^{k} \times \left\{L, R, S\right\}^{k}$. +Legyenek $q, p \in Q$, $a_{1}, a_{2}, ... , a_{k}, b_{1}, b_{2}, ..., b_{k} \in \Gamma$ és +$D_{1}, D_{2}, ..., D_{k} \in \left\{L, R, S\right\}$. Ha $\delta(q,a_{1}, a_{2}, ... , a_{k}) = (p,b_{1}, b_{2}, ..., b_{k}, D_{1}, D_{2}, ..., D_{k})$, akkor a gép akkor a gép a $q$ állapotból, ha a szalagjain rendre az +$a_{1}, a_{2}, ... , a_{k}$ betűket olvassa, át tud menni a $p$ állapotba, miközben az +$a_{1}, a_{2}, ... , a_{k}$ betűket átírja a $b_{1}, b_{2}, ... , b_{k}$ betűkre és a szalagokon a fejeket +$D_{1}, D_{2}, ... , D_{k}$ irányokba mozgatja. + +A többszalagos Turing-gép konfigurációja, a konfigurációátmenet valamint a +felismert illetve eldöntött nyelv definíciója az egyszalagos eset értelemszerű általánosítása. +A többszalagos Turing-gép időigényét is az egyszalagoshoz hasonlóan definiáljuk.\\ + +\noindent \textbf{Többszalagos és egyszalagos gépek ekvivalenciája}: Minden $k$-szalagos, $f(n)$ időkorlátos Turing-géphez +van vele ekvivalens $\mathcal{O}(n*f(n))$ időkorlátos egyszalagos Turing-gép. + +\subsubsection{Nemdeterminisztikus Turing-gépek} + +Egy $M$ nemdeterminisztikus Turing-gép állapotfüggvénye +$\delta : (Q - \left\{q_{i},q_{n}\right\}) \times \mathcal{P}(\Gamma \to Q \times \Gamma \times \left\{L, R\right\})$ +alakú. Tehát $M$ minden konfigurációjából néhány (esetleg nulla) különböző konfigurációba mehet át. +Ily módon $M$ számítási sorozatai egy $u$ szón egy fával reprezentálhatók. A fa csúcsa $M$ kezdőkonfigurációja, +a szögpontjai pedig $M$ konfigurációi. A fa minden levele megfelel $M$ egy számítási sorozatának az +$u$-n. $M$ akkor fogadja el $u$-t, ha a fa valamelyik levele elfogadó konfiguráció. +Nevezzük ezt a most leírt fát az $M$ nemdeterminisztikus számítási fájának az +$u$-n. Az $M$ által felismert nyelv a determinisztikus esethez hasonlóan definiálható, +a gép által eldöntött nyelv pedig a következőképpen.\\ + +\noindent \textbf{Nemdeterminisztikus Turing-gép által eldöntött nyelv}: Azt mondjuk, hogy egy nemdeterminisztikus +$M$ Turing-gép eldönt egy $L \subseteq \Gamma^{*}$ nyelvet, ha felismeri, és minden $u \in \Sigma{*}$ szóra +$M$ számítási sorozatai végesek és elfogadási vagy elutasítási konfigurációba vezetnek.\\ + +\noindent \textbf{Nemdeterminisztikus Turing-gép időigénye}: Legyen $f : \mathbb{N} \to \mathbb{N}$ függvény, $M$ +egy nemdeterminisztikus Turing-gép. Az $M$ időigénye $f(n)$, ha egy $n$ hosszú $u$ bemeneten nincsenek $M$-nek +$f(n)$-nél hosszabb számítási sorozatai, azaz az $M$ számítási fája az $u$-n legfeljebb $f(n)$ magas.\\ + +\noindent \textbf{Determinisztikus és nemdeterminisztikus Turing-gépek ekvivalenciája}: +Minden $M$ nemdeterminisztikus Turing-géphez megadható egy ekvivalens $M'$ determinisztikus Turing-gép. +Továbbá, ha $M$ $f(n)$ időigényű valamely $f : \mathbb{N} \to \mathbb{N}$ függvényre, akkor +$M'$ $2^{\mathcal{O}(f(n))}$ időigényű. + + +\section{Eldönthetetlen problémák} + +Ebben a fejezetben megmutatjuk, hogy bár a Turing-gép a lehető legáltalánosabb +algoritmus modell, mégis vannak olyan problémák, melyek nem számíthatók ki Turing-géppel.\\ + +\noindent \textbf{Emlékeztető}: A rekurzívan felsorolható (Turing-felismerhető) nyelvek osztályát $RE$-vel, +a rekurzív (Turing-eldönthető) nyelvek osztályát $R$-rel jelöljük.\\ + +Világos, hogy $R \subseteq RE $. A célunk az, hogy megmutassuk: az $R$ valódi részhalmaza az $RE$-nek, +azaz van olyan nyelv (probléma) ami Turing-felismerhető, de nem eldönthető. + +Csak olyan Turing-gépeket fogunk vizsgálni, melyek bemenő ábécéje a $\left\{0, 1\right\}$ halmaz. +Ez nem jelenti az általánosság megszorítását, hiszen ha találunk egy olyan $\left\{0, 1\right\}$ feletti nyelvet, +melyet nem lehet eldönteni ilyen Turing-géppel, akkor ezt a nyelvet egyáltalán nem lehet eldönteni.\\ + +\subsubsection{Turing-gépek kódolása} + +A $\left\{0, 1\right\}$ feletti szavak felsorolhatóak (vagyis megszámlálhatóak). Valóban, tekintsük azt a felsorolást, +amelyben a szavak a hosszuk szerint követik egymást, és két egyforma hosszú szó közül pedig az van +előbb, amelyik az alfabetikus rendezés szerint megelőzi a másikat. Ily módon +a $\left\{0, 1\right\}^{*}$ halmaz elemeinek egy felsorolása a következőképpen alakul: $w_{1} = \varepsilon$, +$w_{2} = 0$, $w_{3} = 1$, $w_{4} = 00$, $w_{5} = 01$ és így tovább. Ebben a fejezetben tehát a +$w_{i}$ szóval a $\left\{0, 1\right\}^{*}$ $i$. elemét jelöljük. + +Legyen továbbá $M$ egy $\left\{0, 1\right\}$ inputábécé feletti Turing-gép. Van olyan $k > 0$ szám, hogy +$Q$-t felírhatjuk $Q = \left\{p_{1}, ... p_{k}\right\}$ alakban, ahol $p_{1} = q_{0}$, $p_{k-1} = q_{i}$, $p_{k} = q_{n}$. +Továbbá, van olyan $m > 0$ szám, hogy $\Gamma$-t felírhatjuk $\Gamma = \left\{X_{1}, ... X_{m}\right\}$ alakban, +ahol $X_{1} = 0$, $X_{2} = 1$, $X_{3} = \sqcup$, és $X_{4}, ... X_{m}$ az $M$ további szalagszimbólumai. +Nevezzük végül az $L, R, S$ szimbólumokat (amelyek irányokat jelölnek) rendre $D_{1}$, $D_{2}$ és $D_{3}$-nak. +Ezek után $M$ egy $\delta(p_{i},X_{j}) = (p_{r}, X_{s}, D_{t})$ ($0 \leq i,r \leq k$, $1 \leq j,s \leq m$ és $1 \leq t \leq 3$) +átmenete elkódolható a $0^{i}10^{j}10^{r}10^{s}10^{t}$ szóval. Mivel minden $0$-s blokk hossza legalább $1$, az átmenetet +kódoló szóban nem szerepel az $11$ részszó. Tehát az M összes átmenetét kódoló szavakat összefűzhetjük egy olyan szóvá, +melyben az átmeneteket az $11$ részszó választja el egymástól. Az így kapott szó pedig magát $M$-et kódolja.\\ + +A továbbiakban $M_{i}$-vel jelöljük azt a Turing-gépet, amelyet a $w_{i}$ szó kódol ($i \geq 1$). Amennyiben +$w_{i}$ nem a fent leírt kódolása egy Turing-gépnek, akkor tekintsük $M_{i}$-t olyannak, ami minden input esetén +azonnal a $q_{n}$ állapotba megy, azaz $L(M_{i}) = \emptyset$.\\ + +A későbbiekben szükségünk lesz arra, hogy elkódoljunk egy $(M, w)$ Turing-gép és bemenet +párost egy $\left\{0, 1\right\}$ feletti szóban. Mivel a Turing-gépek kódolása nem tartalmazhat +$111$-et, ezért $(M, w)$ kódja a következő: $M$ kódja után írunk $111$-et, majd utána $w$-t. + +\subsubsection{Egy nem rekurzívan felsorolható nyelv} + +\noindent \textbf{Az $L_{\acute{a}tl\acute{o}}$ nyelv}: Az $L_{\acute{a}tl\acute{o}}$ nyelv azon $\left\{0, 1\right\}$ +feletti Turing-gépek bináris kódjait tartalmazza, melyek nem fogadják el önmaguk kódját, mint bemenő szót, azaz +$L_{\acute{a}tl\acute{o}} = \left\{w_{i} \ | \ i \geq 1, w_{i} \notin L(M_{i}) \right\}$\\ + +\noindent \textbf{Tétel}: $L_{\acute{a}tl\acute{o}} \notin RE$. + +\subsubsection{Egy rekurzívan felsorolható, de nem eldönthető nyelv} + +\noindent \textbf{Az $L_{u}$ nyelv}: Tekintsük azon $(M, w)$ párok halmazát (egy megfelelő bináris szóban elkódolva), +ahol $M$ egy $\left\{0, 1\right\}$ bemenő ábécé feletti Turing-gép, $w$ pedig egy $\left\{0, 1\right\}$ feletti +szó úgy, hogy $w \in L(M)$, azaz $M$ elfogadja $w$-t. Ezt a nyelvet jelöljük $L_{u}$-val. +$L_{u} = \left\{\langle w_{i},w_{j} \rangle \ | \ i, j \geq 1, w_{j} \in L(M_{i}) \right\}$\\ + +\noindent \textbf{Tétel}: $L_{u} \in RE$.\\ + +\noindent \textbf{Tétel}: $L_{u} \notin R$. + +\subsubsection{További tételek} + +\begin{enumerate} + \item Legyen $L$ egy nyelv. Ha $L, \bar{L} \in RE$, akkor $L \in R$. Következmény: a rekurzívan felsorolható + nyelvek nem zártak a komplementerképzésre. + + \item Ha $L \in R$, akkor $\bar{L} \in R$, azaz a rekurzív nyelvek zártak a komplementerképzésre. +\end{enumerate} + +\subsubsection{További eldönthetetlen problémák} + +\noindent \textbf{Kiszámítható függvény}: Legyen $\Sigma$ és $\Delta$ két ábécé és $f$ $\Sigma^{*}$ból +$\Delta^{*}$-ba képző függvény. Azt mondjuk, hogy $f$ kiszámítható, ha van olyan $M$ Turing-gép, hogy +$M$-et egy $w \in \Sigma^{*}$ szóval a bemenetén elindítva, $M$ úgy áll meg, hogy a szalagján a +$f(w) \in \Delta^{*}$ szó van.\\ + +\noindent \textbf{Eldöntési problémák visszavezetése}: Legyen $L_{1} \subseteq \Sigma^{*}$ és $L_{2} \subseteq \Delta^{*}$ +két eldöntési probléma. $L_{1}$ visszavezethető $L_{2}$-re ($L_{1} \leq L_{2}$), ha van olyan +$f : \Sigma^{*} \to \Delta^{*}$ kiszámítható függvény, hogy minden $w \in \Sigma^{*}$ szóra +$w \in L_{1}$ pontosan akkor teljesül, ha $f(w) \in L_{2}$ is teljesül.\\ + +\noindent \textbf{Tétel}: Legyen $L_{1} \subseteq \Sigma^{*}$ és $L_{2} \subseteq \Delta^{*}$ +két eldöntési probléma és tegyük fel, hogy $L_{1}$ visszavezethető $L_{2}$-re. Ekkor igazak a következő állítások: + +\begin{enumerate} + \item Ha $L_{1}$ eldönthetetlen, akkor $L_{2}$ is. + + \item Ha $L_{1} \notin RE$ , akkor $L_{2} \notin RE$. +\end{enumerate} + +\noindent \textbf{A megállási probléma}: Legyen $L_{h} = \left\{\langle M, w \rangle \ |\ M \ meg\acute{a}ll \ a \ w \ bemeneten \right\}$, +azaz $L_{h}$ azon $\langle M, w \rangle$ Turing-gép és bemenet párosokat tartalmazza elkódolva, melyekre $M$ megáll a $w$ bemeneten. +$L_{h}$ eldönthetetlen ($L_{u}$ visszavezethető $L_{h}$-ra), viszont $L_{h} \in RE$.\\ + +\noindent \textbf{Az $L_{\ddot{u}res}$ probléma}: Legyen $L_{\ddot{u}res} = \left\{\langle M \rangle \ |\ L(M) = \emptyset \right\}$. +$L_{\ddot{u}res}$ eldönthetetlen ($L_{u}$ visszavezethető $L_{\ddot{u}res}$-re), valamint $L_{\ddot{u}res} \notin RE$.\\ + +\noindent \textbf{Rekurzívan felsorolható nyelvek (nem triviális) tulajdonsága}: Ha $\mathcal{P}$ a rekurzívan felsorolható +nyelvek egy halmaza, akkor $\mathcal{P}$ a rekurzívan felsorolható nyelvek egy tulajdonsága. Ha $\mathcal{P} \not = \emptyset$ és +$\mathcal{P} \not = RE$, akkor $\mathcal{P}$ nem triviális tulajdonsága a rekurzívan felsorolható nyelveknek.\\ + +\noindent \textbf{Rice tétele}: +Adott $\mathcal{P}$ tulajdonságra jelöljük $L_{\mathcal{P}}$-vel azon Turing-gépek kódjainak halmazát, amelyek +$\mathcal{P}$-beli nyelvet ismernek fel. Ha $\mathcal{P}$ a rekurzívan felsorolható nyelvek egy nem triviális tulajdonsága, akkor +$L_{\mathcal{P}}$ eldönthetetlen.\\ + +\noindent \textbf{Post Megfelelkezési Probléma (röviden PMP)}: A PMP problémát a következőképpen definiáljuk. Legyen +$\Sigma$ egy legalább két betűt tartalmazó ábécé és legyen $D = \left\{[\frac{u_{1}}{v_{1}}], ..., [\frac{u_{n}}{v_{n}}]\right\}$ +egy dominóhalmaz, melyben $n \geq 1$ és $u_{1}, ..., u_{n}, v_{1}, ..., v_{n} \in \Sigma^{+}$. A kérdés az, hogy van-e egy olyan +$1 \leq i_{1}, ..., i_{m} \leq m$ ($m \geq 1$) indexsorozat, melyre teljesül, hogy a $[\frac{u_{i_{1}}}{v_{i_{1}}}], ..., [\frac{u_{i_{m}}}{v_{i_{m}}}]$ dominókat egymás mellé írva alul és felül ugyanaz a szó adódik, azaz +$u_{i_{1}} ... u_{i_{m}} = v_{i_{1}} ... v_{i_{m}}$. Ebben az esetben a fenti dominósorozatot a D egy megoldásának nevezzük. + +Formális nyelvként a következőképpen definiálhatjuk a PMP-t: +PMP $= \left\{ \langle D \rangle \ |\ D-nek \ van \ megold\acute{a}sa \right\}$. PMP eldönthetetlen. + +\section{Bonyolultságelmélet} + +A bonyolultságelmélet célja a megoldható (és ezen belül az eldönthető) problémák osztályozása a megoldáshoz szükséges +erőforrások (jellemzően az idő és a tár) mennyisége szerint. + +\subsubsection{Időbonyolultsági fogalmak} + +\noindent \textbf{TIME}: Legyen $f : \mathbb{N} \to \mathbb{N}$ függvény. \textbf{TIME}($f(n)$) $= \left\{L \ | \ L \ eld\ddot{o}nthet\tilde{o} \ \mathcal{O}(f(n)) \ id\tilde{o}ig\acute{e}ny\tilde{u} \ Turing-g\acute{e}ppel \right\}$\\ + +\noindent \textbf{P} $=\bigcup_{k \geq 1}$ \textbf{TIME}($n^{k}$). Tehát \textbf{P} azon nyelveket tartalmazza, +melyek eldönthetőek polinom időkorlátos determinisztikus Turing-géppel. Ilyen például a jól ismert \textsc{Elérhetőség} +probléma, melynek bemenete egy $G$ gráf és annak két kitüntetett csúcsa ($s$ és $t$). A kérdés az, hogy van-e a $G$-ben +út $s$-ből $t$-be. Ha az \textsc{Elérhetőség} problémára nyelvként tekintünk, akkor írhatjuk azt, hogy\\ + +\textsc{Elérhetőség} $= \left\{\langle G, s, t \rangle \ | \ G-ben \ van \ \acute{u}t \ s-b\tilde{o}l \ t-be\right\}$.\\ + +Könnyen megadható az \textsc{Elérhetőség} problémáját polinom időben eldöntő determinisztikus Turing-gép, tehát +\textsc{Elérhetőség} $\in$ \textbf{P}.\\ + +\noindent \textbf{NTIME}: Legyen $f : \mathbb{N} \to \mathbb{N}$ függvény.\\ \textbf{NTIME}($f(n)$) $= \left\{L \ | \ L \ eld\ddot{o}nthet\tilde{o} \ \mathcal{O}(f(n)) \ id\tilde{o}ig\acute{e}ny\tilde{u} \ nemdeterminisztikus\ Turing-g\acute{e}ppel \right\}$\\ + +\noindent \textbf{NP} $=\bigcup_{k \geq 1}$ \textbf{NTIME}($n^{k}$). +Az \textbf{NP}-beli problémák rendelkeznek egy közös tulajdonsággal az alábbi értelemben. +Ha tekintjük egy \textbf{NP}-beli probléma egy példányát és egy lehetséges "bizonyítékot" +arra nézve, hogy ez a példány "igen" példánya az adott problémának, +akkor ezen bizonyíték helyességének leellenőrzése polinom időben elvégezhető. +Ennek megfelelően egy \textbf{NP}-beli problémát eldöntő nemdeterminisztikus Turing-gép +általában úgy működik, hogy "megsejti" a probléma bemenetének egy lehetséges megoldását, +és polinom időben leellenőrzi, hogy a megoldás helyes-e. + +Tekintsük a \textsc{Sat} problémát, amit a következőképpen definiálunk. Adott egy $\phi$ ítéletlogikai KNF. +A kérdés az, hogy kielégíthető-e. Annak a bizonyítéka, hogy a $\phi$ kielégíthető, egy olyan változó-hozzárendelés, +ami mellett kiértékelve a $\phi$-t igaz értéket kapunk. Egy tetszőleges változó-hozzárendelés tehát a $\phi$ +kielégíthetőségének egy lehetséges bizonyítéka .Annak leellenőrzése pedig, hogy ez a +hozzárendelés tényleg igazzá teszi-e $\phi$-t, polinom időben elvégezhető. A \textsc{Sat} +\textbf{NP}-beli probléma.\\ + +\noindent Az a definíciókból következik, hogy fennáll a \textbf{P} $\subseteq$ \textbf{NP} tartalmazás. + +\subsubsection{NP-teljes problémák} + +\noindent \textbf{Polinom időben kiszámítható függvény}: Legyen $\Sigma$ és $\Delta$ két ábécé és $f$ $\Sigma^{*}$ból +$\Delta^{*}$-ba képző függvény. Azt mondjuk, hogy $f$ polinom időben kiszámítható, ha kiszámítható egy polinom +időigényű Turing-géppel.\\ + +\noindent \textbf{Eldöntési problémák polinom idejű visszavezetése}: +Legyen $L_{1} \subseteq \Sigma^{*}$ és $L_{2} \subseteq \Delta^{*}$ két eldöntési probléma. +$L_{1}$ polinom időben visszavezethető $L_{2}$-re ($L_{1} \leq_{p} L_{2}$), ha $L_{1} \leq L_{2}$ és +a visszavezetésben használt $f$ függvény polinom időben kiszámítható.\\ + +\noindent \textbf{Tétel}: Legyen $L_{1}$ és $L_{2}$ két probléma úgy, hogy $L_{1} \leq_{p} L_{2}$. Ha $L_{2}$ + +\begin{enumerate} + \item \textbf{P}-beli, akkor $L_{1}$ is \textbf{P}-beli. + + \item \textbf{NP}-beli, akkor $L_{1}$ is \textbf{NP}-beli. +\end{enumerate} + +\noindent \textbf{NP-teljes probléma}: Legyen $L$ egy probléma. Azt mondjuk, hogy $L$ \textbf{NP}-teljes, ha + +\begin{enumerate} + \item \textbf{NP}-beli, és + + \item minden további \textbf{NP}-beli probléma polinom időben visszavezethető $L$-re. + +\end{enumerate} + +\noindent \textbf{Tétel}: Legyen $L$ egy \textbf{NP}-teljes probléma. Ha $L \in$ \textbf{P}, akkor \textbf{P} $=$ \textbf{NP}.\\ + +\noindent \textbf{Megjegyzés}: Jelenleg \textbf{NEM} tudunk \textbf{P}-beli \textbf{NP}-teljes problémáról!!!\\ + +\noindent \textbf{Tétel}: Legyen $L_{1}$ egy \textbf{NP}-teljes, $L_{2}$ pedig \textbf{NP}-beli probléma. +Ha $L_{1} \leq_{p} L_{2}$, akkor $L_{2}$ is \textbf{NP}-teljes.\\ + +\noindent \textbf{Cooke tétele}: \textsc{Sat} \textbf{NP}-teljes.\\ + +\noindent Legyen $k \geq 1$. +k\textsc{Sat} $= \left\{\langle \phi \rangle \ | \ \phi \ minden \ tagj\acute{a}ban \ k \ liter\acute{a}l \ van. \right\}$\\ + +\noindent \textbf{Tétel}: 3\textsc{Sat} \textbf{NP}-teljes, ugyanis \textsc{Sat} $\leq_{p}$ 3\textsc{Sat}.\\ + +\noindent \textsc{Teljes részgráf} $= \left\{\langle G, k \rangle \ | \ G \ v\acute{e}ges \ gr\acute{a}f, k \geq 1, \ G-nek \ \exists \ k + \ cs\acute{u}cs\acute{u} \ r\acute{e}szgr\acute{a}fja \right\}$. +Tehát a \textsc{Teljes részgráf} azon $G$ és $k$ párokat tartalmazza, megfelelő ábécé feletti +szavakban elkódolva, melyekre igaz, hogy $G$-ben van $k$ csúcsú teljes részgráf, +azaz olyan részgráf, melyben bármely két csúcs között van él.\\ + +\noindent \textsc{Teljes részgráf}$= \left\{\langle G, k \rangle \ | \ G \ v\acute{e}ges \ gr\acute{a}f, k \geq 1, \ G-nek \ \exists \ k + \ cs\acute{u}cs\acute{u} \ r\acute{e}szgr\acute{a}fja \right\}$. +Tehát a \textsc{Teljes részgráf} azon $G$ és $k$ párokat tartalmazza, megfelelő ábécé feletti +szavakban elkódolva, melyekre igaz, hogy $G$-ben van $k$ csúcsú teljes részgráf, +azaz olyan részgráf, melyben bármely két csúcs között van él.\\ + +\noindent \textsc{Független csúcshalmaz} $= \left\{\langle G, k \rangle \ | \ G \ v\acute{e}ges \ gr\acute{a}f, k \geq 1, \ G-nek \ \exists \ k \ elem\tilde{u} \ f\ddot{u}ggetlen \ cs\acute{u}cshalmaza \right\}$. +Vagyis a \textsc{Független csúcshalmaz} azon $G$ és $k$ párokat tartalmazza, melyekre +igaz, hogy $G$-ben van $k$ olyan csúcs, melyek közül egyik sincs összekötve a +másikkal.\\ + +\noindent \textsc{Csúcslefedés} $=$\\ +$\left\{\langle G, k \rangle \ | \begin{array}{lr} + \ G \ v\acute{e}ges \ gr\acute{a}f, k \geq 1, \ G-nek \ van \ olyan \ k \ elem\tilde{u} \ cs\acute{u}cshalmaza, \\ + mely \ tartalmazza \ G \ minden \ \acute{e}l\acute{e}nek \ legal\acute{a}bb \ 1 \ v\acute{e}gpontj\acute{a}t. + \end{array} + \right\}$.\\ + + +\noindent \textsc{Teljes részgráf}, \textsc{Független csúcshalmaz} és \textsc{Csúcslefedés} \textbf{NP}-teljesek +(\textsc{Teljes részgráf} $\leq_{p}$ \textsc{Független csúcshalmaz} $\leq_{p}$ \textsc{Csúcslefedés}).\\ + +\noindent \textsc{Utazóügynök} $=$\\ +$\left\{\langle G, k \rangle \ | + \begin{array}{lr} + \ G \ v\acute{e}ges \ ir\acute{a}ny\acute{i}tatlan \ gr\acute{a}f, \ az \ \acute{e}leken \ egy-egy \ + pozit\acute{i}v \ eg\acute{e}sz \ s\acute{u}llyal \ \acute{e}s \\ + van \ G-ben \ legfeljebb \ k \ \ddot{o}sszs\acute{u}ly\acute{u} \ Hamilton \ k\ddot{o}r + \end{array} + \right\}$.\\ + +\noindent \textbf{Tétel}: Az \textsc{Utazóügynök} probléma \textbf{NP}-teljes. + +\subsubsection{Tárbonyolultság} +A tárbonyolultságot egy speciális, úgynevezett offline Turing-gépen vizsgáljuk.\\ + +\noindent \textbf{Off-line Turing-gép}: Offline Turing-gépnek nevezünk egy olyan többszalagos Turing-gépet, +mely a bemenetet tartalmazó szalagot csak olvashatja, a többi, ún. munkaszalagokra +pedig írhat is. Az offline Turing-gép tárigényébe csak a munkaszalagokon +felhasznált terület számít be.\\ + +A továbbiakban Turing-gép alatt minidig offline Turing-gépet értünk. Most +definiáljuk a tárbonyolultsággal kapcsolatos nyelvosztályokat.\\ + +\noindent \textbf{SPACE}(f(n)) = $\left\{L|L \ eld\ddot{o}nthet\tilde{o} \ \mathcal{O}(f(n)) \ t\acute{a}rig\acute{e}ny\tilde{u} \ + determinisztikus \ Turing-g\acute{e}ppel \right\}$\\ + +\noindent \textbf{NSPACE}(f(n)) = $\left\{L|L \ eld\ddot{o}nthet\tilde{o} \ \mathcal{O}(f(n)) \ t\acute{a}rig\acute{e}ny\tilde{u} \ + nemdeterminisztikus \ Turing-g\acute{e}ppel \right\}$\\ + +\noindent \textbf{PSPACE} $=\bigcup_{k > 0}$ \textbf{SPACE}($n^{k}$)\\ + +\noindent \textbf{NPSPACE} $=\bigcup_{k > 0}$ \textbf{NSPACE}($n^{k}$)\\ + +\noindent \textbf{L} $=$ \textbf{SPACE}($\log_{2} n$) \\ + +\noindent \textbf{NL} $=$ \textbf{NSPACE}($\log_{2} n$) \\ + +\noindent \textbf{Savitch tétele}: Ha $f(n) \geq \log n$, akkor \textbf{NSPACE}($f(n)$) $\subseteq$ \textbf{SPACE}($f^{2}(n)$). +\end{document} \ No newline at end of file diff --git a/13. Számításelmélet (és Logika)/13.1 Logika.pdf b/13. Számításelmélet (és Logika)/13.1 Logika.pdf new file mode 100644 index 0000000..32c8cc0 Binary files /dev/null and b/13. Számításelmélet (és Logika)/13.1 Logika.pdf differ diff --git a/13. Számításelmélet (és Logika)/13.1 Logika.tex b/13. Számításelmélet (és Logika)/13.1 Logika.tex new file mode 100644 index 0000000..1973860 --- /dev/null +++ b/13. Számításelmélet (és Logika)/13.1 Logika.tex @@ -0,0 +1,773 @@ +\documentclass[margin=0px]{article} + +\usepackage{listings} +\usepackage[utf8]{inputenc} +\usepackage{graphicx} +\usepackage{float} +\usepackage[a4paper, margin=0.7in]{geometry} +\usepackage{amsthm} +\usepackage{amssymb} +\usepackage{fancyhdr} +\usepackage{setspace} + +\onehalfspacing + +\makeatletter +\renewcommand\paragraph{% + \@startsection{paragraph}{4}{0mm}% + {-\baselineskip}% + {.5\baselineskip}% + {\normalfont\normalsize\bfseries}} +\makeatother + +\renewcommand{\figurename}{ábra} + +\newenvironment{tetel}[1]{\paragraph{#1 \\}}{} + +\pagestyle{fancy} +\lhead{\it{PTI BSc Záróvizsga tételek}} +\rhead{13.1 Logika} + +\title{\textbf{{\Large ELTE IK - Programtervező Informatikus BSc} \vspace{0.2cm} \\ {\huge Záróvizsga tételek}} \vspace{0.3cm} \\ 13.1 Logika} +\author{} +\date{} + +\begin{document} +\maketitle + +\begin{tetel}{Logika} + Ítéletkalkulus és elsőrendű predikátumkalkulus: szintaxis, szemantika, ekvivalens átalakítások, a szemantikus következmény fogalma, rezolúció. +\end{tetel} + +\section{Logika} + +\subsection{Alapfogalmak} + +A logika tárgya az emberi gondolkodási folyamat vizsgálata és +helyes gondolkodási formák keresése, illetve létrehozása.\\ + +\noindent Fogalmak: +\begin{enumerate} + \item \textbf{Állítás}: Olyan kijelentés, melynek logikai értéke (igaz + volta) eldönthető, tetszőleges kontextusban igaz vagy hamis. Azt mondjuk, + hogy egy állítás igaz, ha információtartalma megfelel a valóságnak (a tényeknek), + és hamis az ellenkező esetben. + + A mindennapi beszédben használt kijelentő mondatok legtöbbször nem állítások, mivel + a mondat tartalmába a kontextus is beleszámít: időpont, környezet állapota, általános műveltség + bizonyos szintje, stb. (pl. nem állítás az, hogy "ma reggel 8-kor sütött a nap", de állítás pl. az, hogy + "minden páros szám osztható 2-vel"). + + \item \textbf{Igazságérték}: Az igazságértékek halmaza $\mathbb{L}=\left\{igaz,hamis\right\}$. + + \item \textbf{Gondolkodási forma}: Gondolkodási forma alatt egy olyan $(F,A)$ párt értünk, ahol + $A$ állítás, $F=\left\{A_{1},A_{2},...,A_{n}\right\}$ pedig állítások egy halmaza. + + A gondolkodásforma helyes, ha minden esetben, amikor $F$ minden állítása + igaz, akkor $A$ is igaz. +\end{enumerate} + +\subsection{Ítéletkalkulus} + +\subsubsection{Az ítéletlogika szintaxisa} + +\paragraph{Az ítéletlogika ábécéje} +Az ítéletlogika ábécéje $V_{0}=V_{v} \cup \left\{(,)\right\} \cup \left\{\neg, \wedge, \vee, \supset\right\}$, ahol $V_{v}$ az +ítéletváltozók halmaza. Tehát $V_{0}$ az ítéletváltozókat, a zárójeleket, és a logikai műveletek jeleit tartalmazza. + +\paragraph{Az ítéletlogika nyelve} +Az ítéletlogika nyelve ($\mathcal{L}_{0}$) ítéletlogikai formulákból áll, amelyek a következőképpen állnak elő: +\begin{enumerate} + \item Minden ítéletváltozó ítéletlogikai formula. Ezek az úgynevezett prímformulák (vagy atomi formulák). + + \item Ha $A$ ítéletlogikai formula, akkor $\neg A$ is az. + + \item Ha $A$ és $B$ ítéletlogikai formulák, akkor $(A \wedge B)$, $(A \vee B)$ és $(A \supset B)$ is + ítéletlogikai formulák. + + \item Minden ítéletlogikai formula az 1-3. szabályok véges sokszori alkalmazásával áll elő. +\end{enumerate} + +\noindent \textbf{Literál}: Ha $X$ ítéletváltozó, akkor az $X$ és $\neg X$ formulák literálok, amelyek alapja $X$.\\ + +\noindent \textbf{Közvetlen részformula}: +\begin{enumerate} + \item Prímformulának nincs közvetlen részformulája. + + \item $\neg A$ közvetlen részformulája $A$. + + \item $A \circ B$ ($\circ$ a $\wedge, \vee, \supset$ binér összekötőjelek egyike) közvetlen részformulái $A$ (bal oldali) + és $B$ (jobb oldali). +\end{enumerate} + +\noindent \textbf{Részformula}: Legyen $A \in \mathcal{L}_{0}$ egy ítéletlogikai formula. Ekkor $A$ részformuláinak +halmaza a legszűkebb olyan halmaz, melynek +\begin{enumerate} + \item eleme az $A$, és + + \item ha a C formula eleme, akkor C közvetlen részformulái is elemei. + +\end{enumerate} + +\noindent \textbf{Szerkezeti fa}: Egy C formula szerkezeti fája egy olyan véges rendezett fa, melynek csúcsai formulák, +\begin{enumerate} + \item gyökere C, + + \item a $\neg A$ csúcsának pontosan egy gyermeke van, az $A$, + + \item a $A \circ B$ csúcsának pontosan két gyermeke van, rendre az $A$ és $B$ formulák, + + \item levelei prímformulák. +\end{enumerate} + +\begin{figure}[H] + \centering + \includegraphics[width=0.3\linewidth]{img/szerkfa} + \caption{Példa szerkezeti fára.} + \label{fig:szerkfa} +\end{figure} + +\noindent \textbf{Logikai összetettség}: Egy formula logikai összetettsége a benne található logikai összekötőjelek száma.\\ + +\noindent \textbf{Művelet hatásköre}: Egy művelet hatásköre a formula részformulái közül az +a legkisebb logikai összetettségű részformula, melyben az adott művelet előfordul.\\ + +\noindent \textbf{Fő logikai összekötőjel}: Egy formula fő logikai összekötőjele az az összekötőjel, amelynek +hatásköre maga a formula.\\ + +\noindent \textbf{Precedencia}: A logikai összekötőjelek precedenciája csökkenő sorrendben a következő: $\neg, \wedge, \vee, \supset$.\\ + +A definíciók alapján egyértelmű, hogy egy \textit{teljesen zárójelezett formulában} mi a logikai összekötőjelek hatásköre és mi a fő +logikai összekötőjel. Most megmutatjuk, hogy egy formulában milyen esetekben és mely részformulákat határoló zárójelek hagyhatóak el úgy, hogy a logikai összekötőjelek hatásköre ne változzon. A részformulák közül a prímformuláknak és a negációs formuláknak nincs külső zárójelpárja, ezért csak az $(A \circ B)$ alakú részformulákról kell eldöntenünk, hogy írható-e helyettük $A \circ B$. A zárójelek elhagyását +mindig a formula külső zárójelpárjának (ha van ilyen) elhagyásával kezdjük. Majd ha egy részformulában már megvizsgáltuk a külső zárójelelhagyás kérdését, utána ezen részformula közvetlen részformuláinak külső zárójeleivel foglalkozunk. Két eset lehetséges: + +\begin{enumerate} + \item A részformula egy negációs formula, melyben az $(A \circ B)$ alakú közvetlen részformula külső zárójelei nem hagyhatók el. + + \item A részformula egy $(A \bullet B)$ vagy $A \bullet B$ alakú formula, melynek $A$ és $B$ közvetlen részformuláiban kell dönteni a külső zárójelek sorsáról. Ha az $A$ formula $A_{1} \circ A_{2}$ alakú, akkor $A$ külső zárójelpárja akkor hagyható el, ha $\circ$ nagyobb precedenciájú, mint $\bullet$. Ha a $B$ formula $B_{1} \circ B_{2}$ alakú, akkor $B$ külső zárójelpárja akkor hagyható el, ha $\circ$ nagyobb vagy egyenlő precedenciájú, mint $\bullet$. + + \item Ha egy $(A \wedge B)$ vagy $A \wedge B$ alakú formula valamely közvetlen részformulája szintén konjunkció, illetve egy + $(A \vee B)$ vagy $A \vee B$ alakú formula valamely közvetlen részformulája szintén diszjunkció, akkor az ilyen részformulákból a külső zárójelpár elhagyható. +\end{enumerate} + +\noindent \textbf{Formulaláncok}: A zárójelek elhagyására vonatkozó megállapodásokat figyelembe véve úgynevezett konjunkciós, diszjunkciós, illetve implikációs formulaláncokat is nyerhetünk. Ezek alakja $A_{1} \wedge ... \wedge A_{n}$, $A_{1} \vee ... \vee A_{n}$, illetve +$A_{1} \supset ... \supset A_{n}$ Ezeknek a láncformuláknak a fő logikai összekötőjelét a következő zárójelezési megállapodással fogjuk meghatározni: $(A_{1} \wedge (A_{2} \wedge ... \wedge (A_{n-1} \wedge A_{n})...))$, $(A_{1} \vee (A_{2} \vee ... \vee (A_{n-1} \vee A_{n})...))$, illetve $(A_{1} \supset (A_{2} \supset ... \supset (A_{n-1} \supset A_{n})...))$ + +\subsubsection{Az ítéletlogika szemantikája} + +\noindent \textbf{Interpretáció}: $\mathcal{L}_{0}$ interpretációján egy $\mathcal{I} : V_{v} \to \mathbb{L}$ függvényt értünk, mely minden ítéletváltozóhoz egyértelműen hozzárendel egy igazságértéket.\\ + +\noindent \textbf{Boole-értékelés}: $\mathcal{L}_{0}$-beli formulák $\mathcal{I}$ \textit{interpretációbeli Boole-értékelése} a következő $\mathcal{B}_{\mathcal{I}} : \mathcal{L}_{0} \to \mathbb{L}$ függvény: + +\begin{enumerate} + \item ha $A$ prímformula, akkor $\mathcal{B}_{\mathcal{I}}(A) = \mathcal{I}(A)$, + + \item $\mathcal{B}_{\mathcal{I}}(\neg A)$ legyen $\neg \mathcal{B}_{\mathcal{I}}(A) $, + + \item $\mathcal{B}_{\mathcal{I}}(A \wedge B)$ legyen $\mathcal{B}_{\mathcal{I}}(A) \wedge \mathcal{B}_{\mathcal{I}}(B)$, + + \item $\mathcal{B}_{\mathcal{I}}(A \vee B)$ legyen $\mathcal{B}_{\mathcal{I}}(A) \vee \mathcal{B}_{\mathcal{I}}(B)$, + + \item $\mathcal{B}_{\mathcal{I}}(A \supset B)$ legyen $\mathcal{B}_{\mathcal{I}}(A) \supset \mathcal{B}_{\mathcal{I}}(B)$, +\end{enumerate} + +\noindent \textbf{Bázis}: A formula ítéletváltozóinak egy rögzített sorrendje.\\ + +\noindent \textbf{Szemantikus fa}: Egy formula különböző interpretációit szemantikus fa segítségével szemléltethetjük. A szemantikus +fa egy olyan bináris fa, amelynek $i$. szintje ($i>=1$) a bázis $i$. ítéletváltozójához tartozik, és minden csúcsából két él indul, az +egyik a szinthez rendelt ítéletváltozóval, a másik annak negáltjával címkézve. Az $X$ ítéletváltozó esetén az $X$ címke jelentse azt, hogy az $X$ \textit{igaz} az adott interpretációban, a $\neg X$ címke pedig azt, hogy \textit{hamis} az adott interpretációban. A szemantikus fa +minden ága egy-egy lehetséges interpretációt reprezentál. Egy $n$ változós formula esetén minden ág $n$ hosszú, és a fának $2^{n}$ ága van és az összes lehetséges interpretációt tartalmazza. + +\begin{figure}[H] + \centering + \includegraphics[width=0.6\linewidth]{img/szemantikusfa} + \caption{Az X,Y,Z ítéletváltozókat tartalmazó formula szemantikus fája.} + \label{fig:szemantikusfa} +\end{figure} + +\noindent \textbf{Igazságtábla}: Egy $n$ változós formula igazságtáblája egy $n+1$ oszlopból és $2^{n}$ sorból álló táblázat. +A táblázat fejlécében az $i$. oszlophoz ($1<=i<=n$) a formula bázisának $i$. ítéletváltozója, az $n+1$. oszlophoz maga a formula +van hozzárendelve. Az első $n$ oszlopban az egyes sorokhoz megadjuk rendre a formula különböző interpretációit, majd a formula +oszlopába minden sorba beírjuk a formula - a sorhoz tartozó interpretációbeli Boole-értékeléssel kapott - igazságértékét.\\ + +\noindent \textbf{A logikai műveletek igazságtáblája}: + +\begin{table}[H] + \begin{tabular}{ll|lllll} + X & Y & $\neg X$ & $X \wedge Y$ & $X \vee Y$ & $ X \supset Y$ & \\ \hline + i & i & h & i & i & i & \\ + i & h & h & h & i & h & \\ + h & i & i & h & i & i & \\ + h & h & i & h & h & i & + \end{tabular} +\end{table} + +\noindent \textbf{Igazhalmaz, hamishalmaz}: Egy $A$ formula igazhalmaza $(A^{i})$ +azon interpretációk halmaza, melyen a formula igazságértékelése igaz. Az $A$ formula +hamishalmaza $(A^{h})$ pedig azon interpretációk halmaza, melyekre a formula igazságértékelése hamis.\\ + +\noindent \textbf{Igazságértékelés függvény}: Olyan függvény, amely minden formulához hozzárendeli az igazhalmazát ($\varphi A^{i}$) vagy +a hamishalmazát ($\varphi A^{h}$).\\ + +Legyen $A$ egy tetszőleges ítéletlogikai formula. Határozzuk meg $A$-hoz az interpretációira vonatkozó $\varphi A^{i}$, illetve +$\varphi A^{h}$ feltételeket a következőképpen: + +\begin{enumerate} + \item Ha $A$ prímformula, a $\varphi A^{i}$ feltételt pontosan azok az $\mathcal{I}$ interpretációk elégítik ki, melyekre + $\mathcal{I}(A)=igaz$, a $\varphi A^{h}$ feltételt pedig pontosan azok melyekre $\mathcal{I}(A)=hamis$. + + \item A $\varphi (\neg A)^{i}$ feltételek pontosan akkor teljesülnek, ha teljesülnek a $\varphi A^{h}$ feltételek. + + \item A $\varphi (A \wedge B)^{i}$ feltételek pontosan akkor teljesülnek, ha a $\varphi A^{i}$ és a $\varphi B^{i}$ feltételek egyszerre teljesülnek. + + \item A $\varphi (A \vee B)^{i}$ feltételek pontosan akkor teljesülnek, ha a $\varphi A^{i}$ vagy a $\varphi B^{i}$ feltételek teljesülnek. + + \item A $\varphi (A \supset B)^{i}$ feltételek pontosan akkor teljesülnek, ha a $\varphi A^{h}$ vagy a $\varphi B^{i}$ feltételek teljesülnek. +\end{enumerate} + +\noindent \textbf{Tétel}: Tetszőleges $A$ ítéletlogikai formula esetén a $\varphi A^{i}$ feltételeket pontosan az $A^{i}$-beli +interpretációk teljesítik.\\ + +\noindent \textbf{Igazságértékelés-fa}: Egy $A$ formula $\varphi A^{i}$, illetve $\varphi A^{h}$ feltételeket kielégítő interpretációit +az igazságértékelés-fa segítségével szemléltethetjük. Az igazságértékelés-fát a formula szerkezeti fájának felhasználásával állítjuk elő. +A gyökérhez hozzárendeljük, hogy $A$ melyik igazságértékre való igazságértékelés-feltételeit keressük, majd a gyökér alá $A$ közvetlen részformulái kerülnek a megfelelő feltétel-előírással, az alábbiak szerint: + +\begin{figure}[H] + \centering + \includegraphics[width=0.7\linewidth]{img/igazsagertfa} + \caption{Igazságértékelés-fa feltétel-előírásai.} + \label{fig:igazsagertfa} +\end{figure} + +Ezután a gyökérhez a \checkmark (feldolgozott) jelet rendeljük. Az eljárást rekurzívan folytatjuk, amíg egy ágon a fel nem dolgozott +formulák + +\begin{itemize} + \item (a) mind ítéletváltozók nem lesznek, vagy + + \item (b) ugyanarra a formulára egymásnak ellentmondó előírás nem jelenik meg. +\end{itemize} + +Az (a) esetben az ágon előforduló ítéletváltozóknak az ágon rögzített igazságértékeit tartalmazó $n$-esek mind elemei $\varphi A^{i}$ +gyökér esetén a formula igazhalmazának, $\varphi A^{h}$ gyökér esetén a formula hamishalmazának. + +A (b) esetben nem áll elő ilyen igazságérték $n$-es. + +\begin{figure}[H] + \centering + \includegraphics[width=0.5\linewidth]{img/igazsagertfapelda} + \caption{Az $(Y \vee Z) \wedge (Z \supset \neg X)$ formula igazságértékelés-fája.} + \label{fig:igazsagertfapelda} +\end{figure} + +\noindent A fenti példában a formula igazhalmaza az igazságértékelés-fa alapján: $\left\{(i,i,h),(h,i,i),(h,i,h),(h,h,i)\right\}$\\ + +\noindent \textbf{Kiterjesztett igazságtábla}: Egy igazságtáblában a formula igazságértéke kiszámításának megkönnyítésére vezették +be a kiterjesztett igazságtáblát. A kiterjesztett igazságtáblában az ítéletváltozókhoz és a formulához rendelt oszlopokon kívül rendre +a formula részformuláihoz tartozó oszlopok is megjelennek. Tulajdonképpen a szerkezeti fában megjelenő részformulák vannak felsorolva. + +\begin{figure}[H] + \centering + \includegraphics[width=0.5\linewidth]{img/kiterjigaztabla} + \caption{Az $(Y \vee Z) \wedge (Z \supset \neg X)$ formula kiterjesztett igazságtáblája.} + \label{fig:kiterjigaztabla} +\end{figure} + +\noindent \textbf{Formula kielégíthetősége, modellje}: Egy $A$ ítéletlogikai formula \textit{kielégíthető}, ha létezik olyan $\mathcal{I}$ +interpretáció, melyre $\mathcal{I} \models_{0} A$, azaz a $\mathcal{B}_{\mathcal{I}}$ Boole-értékelés $A$-hoz igaz értéket rendel. Egy +ilyen interpretációt $A$ \textit{modelljének} nevezünk. Ha $A$-nak nincs modellje, akkor azt mondjuk, hogy \textit{kielégíthetetlen}. + +Ha $A$ igazságtáblájában van olyan sor, amelyben a formula oszlopában igaz érték szerepel, akkor a formula kielégíthető, különben kielégíthetetlen. Ugyanígy, ha $\varphi A^{i}$ nem üres, akkor kielégíthető, különben kielégíthetetlen.\\ + +\noindent \textbf{Ítéletlogikai törvény, tautológia}: Egy $A$ ítéletlogikai formula \textit{ítéletlogikai törvény} vagy másképpen \textit{tautológia}, ha $\mathcal{L}_{0}$ minden interpretációja modellje $A$-nak. (jelölés: $\models_{0} A$)\\ + +\noindent \textbf{Eldöntésprobléma}: Eldöntésproblémának nevezzük a következő feladatokat: +\begin{enumerate} + \item Döntsük el tetszőleges formuláról, hogy tautológia-e! + + \item Döntsük el tetszőleges formuláról, hogy kielégíthetetlen-e! +\end{enumerate} + +\noindent \textbf{Tautologikusan ekvivalens formulák}: Az $A$ és $B$ ítéletlogikai formulák \textit{tautologikusan ekvivalensek} (jelölés: $A \sim _{0} B$), ha $\mathcal{L}_{0}$ minden $\mathcal{I}$ interpretációjában $\mathcal{B}_{\mathcal{I}}(A)=\mathcal{B}_{\mathcal{I}}(B)$.\\ + +\noindent \textbf{Formulahalmaz kielégíthetősége, modellje}: $\mathcal{L}_{0}$ formuláinak egy tetszőleges $\Gamma$ halmaza +kielégíthető, ha van $\mathcal{L}_{0}$-nak olyan $\mathcal{I}$ interpretációja, melyre: $\forall A \in \Gamma: \mathcal{I} \models_{0} A$. +Egy ilyen $\mathcal{I}$ interpretáció modellje $\Gamma$-nak. Ha $\Gamma$-nak nincs modellje, akkor $\Gamma$ kielégíthetetlen.\\ + +\noindent \textbf{Lemma}: Egy $\left\{A_{1},A_{2},...,A_{n}\right\}$ formulahalmaznak pontosan azok az $\mathcal{I}$ interpretációk +a modelljei, amelyek a $A_{1} \wedge A_{2} \wedge ... \wedge A_{n}$ formulának. Következésképpen $\left\{A_{1},A_{2},...,A_{n}\right\}$ +pontosan akkor kielégíthetetlen, ha az $A_{1} \wedge A_{2} \wedge ... \wedge A_{n}$ formula kielégíthetlen.\\ + +\noindent \textbf{Szemantikus következmény}: Legyen $\Gamma$ ítéletlogikai formulák tetszőleges halmaza, $B$ egy tetszőleges formula. +Azt mondjuk, hogy a $B$ formula \textit{tautologikus következménye} a $\Gamma$ formulahalmaznak (jelölés: $\Gamma \models_{0} B$), ha minden olyan interpretáció, amely modellje $\Gamma$-nak, modellje $B$-nek is. A $\Gamma$-beli formulákat feltételformuláknak, vagy premisszáknak, +a B formulát következményformulának (konklúziónak) hívjuk.\\ + +\noindent \textbf{Tétel}: Legyen $\Gamma$ ítéletlogikai formulák tetszőleges halmaza, $A$,$B$,$C$ tetszőleges ítéletlogikai formulák. +Ha $\Gamma \models_{0} A$, $\Gamma \models_{0} B$ és $\left\{A,B\right\} \models_{0} C$, akkor $\Gamma \models_{0} C$.\\ + +\noindent \textbf{Tétel}: Legyenek $A_{1},A_{2},...,A_{n}, B$ tetszőleges ítéletlogikai formulák. +$\left\{A_{1},A_{2},...,A_{n}\right\} \models_{0} B$ pontosan akkor, ha a $\left\{A_{1},A_{2},...,A_{n}, \neg B\right\}$ +formulahalmaz kielégíthetetlen, azaz a $A_{1} \wedge A_{2} \wedge ... \wedge A_{n} \wedge \neg B$ formula kielégíthetetlen.\\ + +\noindent \textbf{Tétel}: Legyenek $A_{1},A_{2},...,A_{n}, B$ tetszőleges ítéletlogikai formulák. +$\left\{A_{1},A_{2},...,A_{n}\right\} \models_{0} B$ pontosan akkor, ha +$\models_{0} A_{1} \wedge A_{2} \wedge ... \wedge A_{n} \supset B$.\\ + +\paragraph{Ekvivalens átalakítások} +Fogalmak: +\begin{enumerate} + \item Egy prímformulát (ítéletváltozót), vagy annak a negáltját közös néven \textit{literálnak} nevezünk. A prímformula + a \textit{literál alapja}. Egy literált bizonyos esetekben \textit{egységkonjunkciónak} vagy \textit{egységdiszjunkciónak} + (\textit{egységklóznak}) is hívunk. + + \item \textit{Elemi konjunkció} az egységkonjunkció, illetve a különböző alapú literálok konjunkciója ($\wedge$ kapcsolat + a literálok között). \textit{Elemi diszjunkció} vagy \textit{klóz} az egységdiszjunkció és a különböző alapú literálok + diszjunkciója ($\vee$ kapcsolat a literálok között). Egy elemi konjunkció, illetve elemi diszjunkció \textit{teljes} + egy $n$-változós logikai műveletre nézve, ha mind az $n$ ítéletváltozó alapja valamely literáljának. + + \item \textit{Diszjunktív normálformának} (DNF) nevezzük az elemi konjunkciók diszjunkcióját. + \textit{Konjunktív normálformának} (KNF) nevezzük az elemi diszjunkciók konjunkcióját. \textit{Kitüntetett} + diszjunktív, illetve konjunktív normálformákról (KDNF, ileltve KKNF) beszélünk, ha a bennük szereplő + elemi konjunkciók, illetve elemi diszjunkciók teljesek. + +\end{enumerate} + +\noindent \textbf{Tetszőleges logikai műveletet leíró KDNF, KKNF előállítása}: Legyen $b: \mathbb{L}^{n} \to \mathbb{L}$ +egy $n$-változós logikai művelet. Adjuk meg $b$ művelettábláját. +Az első $n$ oszlop fejlécébe az $X_{1}$, $X_{2}$, ... $X_{n}$ ítéletváltozókat írjuk.\\ + +\noindent A $b$-t leíró KDNF előállítása: + +\begin{enumerate} + \item Válasszuk ki azokat a sorokat a művelettáblában, ahol az adott igazságérték $n$-eshez $b$ \textit{igaz} + értéket rendel hozzá. Legyenek ezek a sorok rendre $s_{1}, s_{2}, .. s_{r}$. Minden ilyen sorhoz rendeljünk + hozzá egy $X_{1}' \wedge X_{2}' \wedge ... \wedge X_{n}'$ teljes elemi konjunkciót úgy, hogy az $X_{j}'$ literál + $X_{j}$ vagy $\neg X_{j}$ legyen aszerint, hogy ebben a sorban $X_{j}$ \textit{igaz} vagy \textit{hamis} igazságérték + szerepel. Az így nyert teljes elemi konjunkciók legyenek rendre $k_{s_{1}}, k_{s_{2}}, .. k_{s_{r}}$. + + \item Az így kapott teljes elemi konjunkciókból készítsünk egy diszjunkciós láncformulát: + $k_{s_{1}} \vee k_{s_{2}} \vee ... \vee k_{s_{r}}$. Ez a formula lesz a $b$ művelet kitüntetett diszjunktív + normálformája (KDNF). +\end{enumerate} + +\begin{figure}[H] + \centering + \includegraphics[width=0.5\linewidth]{img/kdnf_pelda} + \caption{Egy háromváltozós $b$ logikai művelet művelettáblája és az előállított teljes elemi konjunkciók.} + \label{fig:kdnf_pelda} +\end{figure} + +A fenti példa $b$ műveletének kitüntetett diszjunktív normálformája a következő formula:\\ +$(X \wedge Y \wedge \neg Z) \vee (X \wedge \neg Y \wedge \neg Z) \vee (\neg X \wedge Y \wedge Z) \vee (\neg X \wedge \neg Y \wedge Z) \vee (\neg X \wedge \neg Y \wedge \neg Z)$.\\ + +\noindent A $b$-t leíró KKNF előállítása: + +\begin{enumerate} + \item Válasszuk ki azokat a sorokat a művelettáblában, ahol az adott igazságérték $n$-eshez $b$ \textit{hamis} + értéket rendel hozzá. Legyenek ezek a sorok rendre $s_{1}, s_{2}, .. s_{r}$. Minden ilyen sorhoz rendeljünk + hozzá egy $X_{1}' \vee X_{2}' \vee ... \vee X_{n}'$ teljes elemi diszjunkciót úgy, hogy az $X_{j}'$ literál + $X_{j}$ vagy $\neg X_{j}$ legyen aszerint, hogy ebben a sorban $X_{j}$ \textit{hamis} vagy \textit{igaz} igazságérték + szerepel. Az így nyert teljes elemi diszjunkciók legyenek rendre $d_{s_{1}}, d_{s_{2}}, .. d_{s_{r}}$. + + \item Az így kapott teljes elemi diszjunkciókból készítsünk egy konjunkciós láncformulát: + $d_{s_{1}} \wedge d_{s_{2}} \wedge ... \wedge d_{s_{r}}$. Ez a formula lesz a $b$ művelet kitüntetett konjunktív + normálformája (KKNF). +\end{enumerate} + +\begin{figure}[H] + \centering + \includegraphics[width=0.5\linewidth]{img/kknf_pelda} + \caption{Egy háromváltozós $b$ logikai művelet művelettáblája és az előállított teljes elemi diszjunkciók.} + \label{fig:kknf_pelda} +\end{figure} + +A fenti példa $b$ műveletének kitüntetett konjunktív normálformája a következő formula:\\ +$(\neg X \vee \neg Y \vee \neg Z) \wedge (\neg X \vee Y \vee \neg Z) \wedge (X \vee Y \vee \neg Z)$. \\ + +\noindent \textbf{KNF, DNF egyszerűsítése}: Egy ítéletlogikai formula logikai összetettségén a formulában szereplő +logikai összekötőjelek számát értettük. Ugyanazt a logikai műveletet leíró formulák közül azt tekintjük egyszerűbbnek, +amelynek kisebb a logikai összetettsége (azaz kevesebb logikai összekötőjelet tartalmaz). + +Legyen $X$ egy ítéletváltozó $k$ egy az $X$-et nem tartalmazó elemi konjunkció, $d$ egy $X$-et nem tartalmazó elemi +diszjunkció. Ekkor az + +\begin{itemize} + \item (a) $(X \wedge k) \vee (\neg X \wedge k) \sim_{0} k $ és + + \item (b) $(X \vee d) \wedge (\neg X \vee d) \sim_{0} d $ +\end{itemize} + +egyszerűsítési szabályok alkalmazásával konjunktív és diszjunktív normálformákat írhatunk át egyszerűbb alakba.\\ + +\noindent Klasszikus Quine--McCluskey-féle algoritmus KDNF egyszerűsítésére: + +\begin{enumerate} + \item Soroljuk fel a KDNF-ben szereplő összes teljes elemi konjunkciót az $L_{0}$ listában, $j:=0$. + + \item Megvizsgáljuk az $L_{j}$-ben szereplő összes lehetséges elemi konjunkciópárt, hogy alkalmazható-e + rájuk az (a) egyszerűsítési szabály. Ha igen, akkor a két kiválasztott konjunkciót $\checkmark$-val megjelöljük, + és az eredmény konjunkciót beírjuk a $L_{j+1}$ listába. Azok az elemi konjunkciók, amelyek az $L_{j}$ vizsgálata + során nem lesznek megjelölve, nem voltak egyszerűsíthetők, tehát bekerülnek az egyszerűsített diszjunktív + normálformába. + + \item Ha az $L_{j+1}$ konjunkciólista nem üres, akkor $j:=j+1$. Hajtsuk végre újból a 2. lépést. + + \item Az algoritmus során kapott, de meg nem jelölt elemi konjunkciókból készítsünk egy diszjunkciós + láncformulát. Így az eredeti KDNF-el logikailag ekvivalens, egyszerűsített DNF-et kapunk. +\end{enumerate} + +\paragraph{Rezolúció} + +Legyenek $A_{1}, A_{2}, ... , A_{n}, B$ tetszőleges ítéletlogikai formulák. +Azt szeretnénk bebizonyítani, hogy $\left\{A_{1}, A_{2}, ... , A_{n}\right\} \models_{0} B$, +ami ekvivalens azzal, hogy $\left\{A_{1}, A_{2}, ... , A_{n}, \neg B\right\}$ kielégíthetetlen. +Írjuk át ez utóbbi formulahalmaz formuláit KNF alakba! Ekkor a +$\left\{KNF_{A_{1}}, KNF_{A_{2}}, ... , KNF_{A_{n}}, KNF_{\neg B}\right\}$ formulahalmazt +kapjuk, ami pontosan akkor kielégíthetetlen, ha a halmaz formuláiban szereplő klózok halmaza +kielégíthetetlen. + +A klózokra vonatkozó egyszerűsítési szabály szerint ha $X$ ítéletváltozó, $C$ pedig $X$-et nem +tartalmazó klóz, akkor $(X \vee C) \wedge (\neg X \vee C) \sim_{0} C$. Az $X$ és a $\neg X$ +egységklózok (azt mondjuk, hogy $X$ és $\neg X$ komplemens literálpár) konjunkciójával ekvivalens +egyszerűbb, egyetlen literált sem tartalmazó klóz az üres klóz, melyet a $\square$ jellel +jelölünk és definíció szerint minden interpretációban hamis igazságértékű. + +Legyenek most $C_{1}$ és $C_{2}$ olyan klózok, melyek pontosan egy komplemens literálpárt tartalmaznak, +azaz $C_{1} = C_{1}' \vee L_{1}$ és $C_{2} = C_{2}' \vee L_{2}$, ahol $L_{1}$ és $L_{2}$ az egyetlen +komplemens literálpár ($C_{1}'$ és $C_{2}'$ üres klózok is lehetnek). Világos, hogy ha a két klózban +a komplemens literálpáron kívül is vannak literálok, és ezek nem mind azonosak, az egyszerűsítési +szabály alkalmazhatósági feltétele nem áll fenn.\\ + +\noindent \textbf{Tétel}: Ha $C_{1} = C_{1}' \vee L_{1}$ és $C_{2} = C_{2}' \vee L_{2}$, +ahol $L_{1}$ és $L_{2}$ komplemens literálpár, akkor $\left\{C_{1},C_{2}\right\} \models_{0} C_{1}' \vee C_{2}'$\\ + +\noindent \textbf{Rezolvens}: Legyenek $C_{1}$ és $C_{2}$ olyan klózok, melyek pontosan egy komplemens literálpárt tartalmaznak, +azaz $C_{1} = C_{1}' \vee L_{1}$ és $C_{2} = C_{2}' \vee L_{2}$, ahol $L_{1}$ és $L_{2}$ a komplemens literálpár, +a $C_{1}' \vee C_{2}'$ klózt a $(C_{1},C_{2})$ klózpár (vagy a $C_{1} \vee C_{2}$ formula) \textit{rezolvensének} nevezzük. +Ha $C_{1} = L_{1}$ és $C_{2} = L_{2}$ (azaz $C_{1}'$ és $C_{2}'$ üres klózok), rezolvensük az üres klóz ($\square$). +Az a tevékenység, melynek eredménye a rezolvens, a \textit{rezolválás}. + +\begin{figure}[H] + \centering + \includegraphics[width=0.7\linewidth]{img/rezolvens} + \caption{Példák klózpárok rezolválhatóságára, rezolvensére.} + \label{fig:rezolvens} +\end{figure} + +\noindent \textbf{Tétel}: Ha a $C$ klóz a $(C_{1},C_{2})$ klózpár rezolvense, akkor azon $\mathcal{I}$ interpretációk +a $\left\{C_{1}, C_{2}\right\}$ klózhalmazt nem elégíthetik ki, amelyekben $C$ igazságértéke hamis, azaz +$\mathcal{B}_{\mathcal{I}}(C) = hamis$.\\ + +\noindent \textbf{Rezolúciós levezetés}: Egy $S$ klózhalmazból a $C$ klóz rezolúciós levezetése egy olyan véges +$k_{1}, k_{2}, ... ,k_{m} (m \geq 1)$ klózsorozat, ahol minden $j = 1, 2, ..., m$-re + +\begin{enumerate} + \item vagy $k_{j} \in S$, + + \item vagy van olyan $1 \leq s,t \le j$, hogy $k_{j}$ a $(k_{s}, k_{t})$ klózpár rezolvense, +\end{enumerate} + +\noindent és a klózsorozat utolsó tagja, $k_{m}$, éppen a $C$ klóz. + +Megállapodásunk szerint a rezolúciós kalkulus eldöntésproblémája az, hogy levezethető-e $S$-ből $\square$. A +rezolúciós levezetés célja tehát $\square$ levezetése $S$-ből. Azt, hogy $\square$ levezethető $S$-ből, +úgy is ki lehet fejezni, hogy létezik $S$-nek rezolúciós cáfolata.\\ + +\noindent Példa: Próbáljuk meg levezetni $\square$-t az +$S = \left\{\neg X \vee Y, \neg Y \vee Z, X \vee Z, \neg V \vee Y \vee Z, \neg Z \right\}$ +klózhalmazból. A levezetés bármelyik $S$-beli klózból indítható. + +\begin{figure}[H] + \centering + \includegraphics[width=0.4\linewidth]{img/rezoluciopelda} + \caption{$\square$ rezolúciós levezetése $S$-ből.} + \label{fig:rezoluciopelda} +\end{figure} + +\noindent \textbf{Lemma}: Legyen $S$ tetszőleges klózhalmaz. $S$-ből történő rezolúciós levezetés esetén bármely $S$-ből +levezetett klóz tautologikus következménye $S$-nek.\\ + +\noindent \textbf{A rezolúciós kalkulus helyessége}: A rezolúciós kalkulus \textit{helyes}, azaz tetszőleges +$S$ klózhalmaz esetén amennyiben $S$-ből levezethető $\square$, akkor $S$ \textit{kielégíthetetlen}.\\ + +\noindent \textbf{A rezolúciós kalkulus teljessége}: A rezolúciós kalkulus \textit{teljes}, azaz bármely véges, kielégíthetetlen +$S$ klózhalmaz esetén $S$-ből levezethető $\square$.\\ + +\noindent \textbf{Levezetési fa}: Egy rezolúciós levezetés szerkezetét \textit{levezetési fa} segítségével szemléltethetjük. +A levezetési fa csúcsai klózok. Két csúcsból pontosan akkor vezet él egy harmadik, közös csúcsba, ha az a két klóz rezolvense. + +\begin{figure}[H] + \centering + \includegraphics[width=0.5\linewidth]{img/rezoluciopelda_levfa} + \caption{Az előző példa levezetési fája.} + \label{fig:rezoluciopelda_levfa} +\end{figure} + +\noindent \textbf{Rezolúciós stratégiák}: + +\begin{itemize} + \item \textit{Lineáris rezolúció}: Egy $S$ klózhalmazból való lineáris rezolúciós levezetés egy olyan + $k_{1},l_{1},k_{2},l_{2}, ..., k_{m-1},l_{m-1}, k_{m}$ rezolúciós levezetés, amelyben minden + $j = 2, 3, ..., m$-re $k_{j}$ a $(k_{j-1},l_{j-1})$ klózpár rezolvense. A $k_{j}$ klózokat centrális + klózoknak, az $l_{j}$ klózokat mellékklózoknak nevezzük. + + Tetszőleges rezolúciós levezetés átírható lineárissá, azaz a lineáris rezolúciós kalkulus teljes. + + \item \textit{Lineáris inputrezolúció}: Egy $S$ klózhalmazból való lineáris inputrezolúciós levezetés + egy olyan $k_{1},l_{1},k_{2},l_{2}, ..., k_{m-1},l_{m-1}, k_{m}$ lineáris rezolúciós levezetés, amelyben minden + $j = 1, 2, ..., m-1$-re $l_{j} \in S$, azaz a lineáris inputrezolúciós levezetésben a mellékklózok $S$ elemei. + + A lineáris inputrezolúciós stratégia nem teljes, de megadható olyan formulaosztály, melyre az. A legfeljebb egy + negált literált tartalmazó klózokat Horn-klózoknak nevezzük, a Horn-formulák pedig azok a formulák, melyek + konjunktív normálformája Horn-klózok konjunkciója. A lineáris inputrezolúciós stratégia Horn-formulák esetén teljes. +\end{itemize} + +\subsection{Predikátumkalkulus} + +\subsubsection{Elsőrendű logikai nyelvek szintaxisa} + +Egy elsőrendű logikai nyelv ábécéje logikai és logikán kívüli szimbólumokat, továbbá elválasztójeleket tartalmaz. +A logikán kívüli szimbólumhalmaz megadható $$ alakban, ahol: + +\begin{enumerate} + \item $Srt$ nemüres halmaz, elemei fajtákat szimbolizálnak, + + \item $Pr$ nemüres halmaz, elemei predikátumszimbólumok, + + \item az $Fn$ halmaz elemei függvényszimbólumok, + + \item $Cnst$ pedig a függvényszimbólumok halmaza. +\end{enumerate} + +\noindent Az $$ ábécé szignatúrája egy $<\nu_{1}, \nu_{2}, \nu_{3}>$ hármas, ahol + +\begin{enumerate} + \item minden $P \in Pr$ predikátumszimbólumhoz $\nu_{1}$ a predikátumszimbólum alakját, + azaz a $(\pi_{1}, \pi_{2}, ..., \pi_{k})$ fajtasorozatot, + + \item minden $f \in Fn$ függvényszimbólumhoz $\nu_{2}$ a függvényszimbólum alakját, + azaz a $(\pi_{1}, \pi_{2}, ..., \pi_{k}, \pi)$ fajtasorozatot és + + \item minden $c \in Cnst$ konstansszimbólumhoz $\nu_{3}$ a konstansszimbólumhoz alakját, + azaz $(\pi)$-t +\end{enumerate} + +\noindent rendel ($k > 0$ és $\pi_{1}, \pi_{2}, ..., \pi_{k}, \pi \in Srt$). + +Logikai jelek az ítéletlogikában is használt logikai összekötőjelek, valamint az univerzális ($\forall$) +és egzisztenciális ($\exists$) kvantorok és a különböző fajtájú individuumváltozók. Egy elsőrendű +nyelv ábécéjében minden $\pi \in Srt$ fajtához szimbólumoknak megszámlálhatóan végtelen +$v_{1}^{\pi}, v_{2}^{\pi}, ...$ rendszere tartozik, ezeket a szimbólumokat nevezzük $\pi$ fajtájú +változóknak. Elválasztójel a nyitó és csukó zárójelek, és a vessző. + +Az elsőrendű logikai nyelvekben az elválasztójelek és a logikai jelek mindig ugyanazok, viszont +a logikán kívüli jelek halmaza, illetve ezek szignatúrája nyelvről nyelvre lényegesen különbözhet. +Ezért mindig megadjuk a $$ négyest és ennek $<\nu_{1}, \nu_{2}, \nu_{3}>$ +szignatúráját, amikor egy elsőrendű logikai nyelv ábécéjére hivatkozunk. Jelölése $V[V_{\nu}]$, +ahol $V_{\nu}$ adja meg a $<\nu_{1}, \nu_{2}, \nu_{3}>$ szignatúrájú $$ négyest.\\ + +\noindent \textbf{Termek}: A $V[V_{\nu}]$ ábécé feletti termek halmaza $\mathcal{L}_{t}[V_{\nu}]$, ami +a következő tulajdonságokkal bír: + +\begin{enumerate} + \item Minden $\pi \in Srt$ fajtájú változó és konstans $\pi$ fajtájú term. + + \item Ha az $f \in Fn$ függvényszimbólum $(\pi_{1}, \pi_{2}, ..., \pi_{k}, \pi)$ alakú + és $t_{1}, t_{2}, ..., t_{k}$ -- rendre $\pi_{1}, \pi_{2}, ..., \pi_{k}$ fajtájú -- termek, + akkor az $f(s_{1}, s_{2}, ..., s_{k})$ egy $\pi$ fajtájú term. + + \item Minden term az 1-2. szabályok véges sokszori alkalmazásával áll elő. +\end{enumerate} + +\noindent \textbf{Formulák}: A $V[V_{\nu}]$ ábécé feletti elsőrendű formulák halmaza $\mathcal{L}_{f}[V_{\nu}]$, ami +a következő tulajdonságokkal bír: + +\begin{enumerate} + \item Ha a $P \in Pr$ predikátumszimbólum $(\pi_{1}, \pi_{2}, ..., \pi_{k})$ alakú + és az $t_{1}, t_{2}, ..., t_{k}$ -- rendre $\pi_{1}, \pi_{2}, ..., \pi_{k}$ fajtájú -- + termek, akkor a $P(t_{1}, t_{2}, ..., t_{k})$ szó egy elsőrendű formula. + Az így nyert formulákat atomi formuláknak nevezzük. + + \item Ha $S$ elsőrendű formula, akkor $\neg S$ is az. + + \item Ha $S$ és $T$ elsőrendű formulák és $\circ$ binér logikai összekötőjel, + akkor $(S \circ T)$ is elsőrendű formula. + + \item Ha $S$ eleme elsőrendű formula, $Q$ kvantor ($\forall$ vagy $\exists$) és $x$ + tetszőleges változó, akkor $QxS$ is elsőrendű formula. Az így nyert formulákat kvantált formuláknak nevezzük, + a $\forall xS$ alakú formulák univerzálisan kvantált formulák, a $\exists xS$ alakú formulák + pedig egzisztenciálisan kvantált formulák. A kvantált formulákban $Qx$ a formula prefixe, $S$ + pedig a magja. + + \item Minden elsőrendű formula az 1-4. szabályok véges sokszori alkalmazásával áll elő. +\end{enumerate} + +\noindent A $V[V_{\nu}]$ ábécé feletti elsőrendű logikai nyelv +$\mathcal{L}[V_{\nu}] = \mathcal{L}_{t}[V_{\nu}] \cup \mathcal{L}_{f}[V_{\nu}]$, azaz $\mathcal{L}[V_{\nu}]$ +minden szava vagy term, vagy formula.\\ + +A negációs, konjunkciós, diszjunkciós, implikációs (ezek jelentése ua., mint nulladrendben) és kvantált formulák +összetett formulák. + +Az elsőrendű logikai nyelv prímformulái az atomi formulák és a kvantált formulák.\\ + +\noindent \textbf{Változóelőfordulás fajtái}: Egy formula $x$ változójának egy előfordulása: + +\begin{itemize} + \item szabad, ha nem esik $x$-re vonatkozó kvantor hatáskörébe, + + \item kötött, ha $x$-re vonatkozó kvantor hatáskörébe esik. +\end{itemize} + +\noindent \textbf{Változó fajtái}: Egy formula $x$ változója: + +\begin{itemize} + \item szabad, ha minden előfordulása szabad, + + \item kötött, ha minden előfordulása kötött, és + + \item vegyes, ha van szabad és kötött előfordulása is. +\end{itemize} + +\noindent \textbf{Formula zártsága, nyíltsága}: Egy formula: + +\begin{itemize} + \item zárt, ha minden változója kötött, + + \item nyílt, ha legalább egy változójának van szabad előfordulása és + + \item kvantormentes, ha nincs benne kvantor +\end{itemize} + +Megjegyzés: a zárt formulák elsőrendű állításokat szimbolizálnak (egy elsőrendű állítás nem más, mint elemek egy halmazára +megfogalmazott kijelentő mondat). + +\subsubsection{Az elsőrendű logika szemantikája} + +\noindent \textbf{Matematikai struktúra}: Matematikai struktúrán egy $$ négyest értünk, ahol: + +\begin{enumerate} + \item $U = \bigcup_{\pi} U_{\pi}$ nem üres alaphalmaz (univerzum), + + \item $R$ az $U$-n értelmezett logikai függvények (relációk) halmaza, + + \item $M$ az $U$-n értelmezett matematikai függvények (alapműveletek) halmaza, + + \item $K$ az $U$ kijelölt elemeinek (konstansainak) halmaza (lehet üres). +\end{enumerate} + +\noindent \textbf{Interpretáció}: Az interpretáció egy $$ matematikai struktúra és +$\mathcal{I} = <\mathcal{I}_{Srt}, \mathcal{I}_{Pr}, \mathcal{I}_{Fn}, \mathcal{I}_{Cnst}>$ +függvénynégyes, ahol: + +\begin{itemize} + \item az $\mathcal{I}_{Srt} : \pi \mapsto U_{\pi}$ függvény megad minden egyes $\pi \in Srt$ fajtához + egy $U_{\pi}$ nemüres halmazt, a $\pi$ fajtájú individuumok halmazát, + + \item az $\mathcal{I}_{Pr} : P \mapsto P^{\mathcal{I}}$ függvény megad minden + $(\pi_{1}, \pi_{2}, ..., \pi_{k})$ alakú $P \in Pr$ predikátumszimbólumhoz egy + $P^{\mathcal{I}} : U_{\pi_{1}} \times U_{\pi_{2}} \times ... \times U_{\pi_{k}} \to \mathbb{L}$ + logikai függvényt (relációt), + + \item az $\mathcal{I}_{Fn} : f \mapsto f^{\mathcal{I}}$ függvény hozzárendel minden + $(\pi_{1}, \pi_{2}, ..., \pi_{k}, \pi)$ alakú $f \in Fn$ függvényszimbólumhoz egy + $P^{\mathcal{I}} : U_{\pi_{1}} \times U_{\pi_{2}} \times ... \times U_{\pi_{k}} \to U_{\pi}$ + matematikai függvényt (műveletet), + + \item az $\mathcal{I}_{Cnst} : c \mapsto ct^{\mathcal{I}}$ pedig minden $\pi$ fajtájú + $c \in Cnst$ konstansszimbólumhoz az $U_{\pi}$ individuumtartománynak egy individuumát + rendeli, azaz $c^{\mathcal{I}} \in U_{\pi}$. +\end{itemize} + +\noindent \textbf{Változókiértékelés}: Legyen az $\mathcal{L}[V_{\nu}]$ nyelvnek $\mathcal{I}$ egy interpretációja, +az interpretáció univerzuma legyen U és jelölje V a nyelv változóinak halmazát. Egy olyan $\kappa : V \to U$ leképezést, +ahol ha $x$ $\pi$ fajtájú változó, akkor $\kappa(x) \in U_{\pi}$, $\mathcal{I}$-beli változókiértékelésnek nevezünk.\\ + +\noindent \textbf{$\mathcal{L}_{t}[V_{\nu}]$ szemantikája}: +Legyen az $\mathcal{L}[V_{\nu}]$ nyelvnek $\mathcal{I}$ egy interpretációja és $\kappa$ egy $\mathcal{I}$-beli +változókiértékelés. Az $\mathcal{L}[V_{\nu}]$ nyelv egy $\pi$ fajtájú $t$ termjének értéke $\mathcal{I}$-ben +a $\kappa$ változókiértékelés mellett az alábbi -- $|t|^{\mathcal{I},\kappa}$-val jelölt -- $U_{\pi}$-beli +individuum: + +\begin{enumerate} + \item ha $c \in Cnst$ $\pi$ fajtájú konstansszimbólum, akkor $|c|^{\mathcal{I},\kappa}$ az $U_{\pi}$-beli + $c^{\mathcal{I}}$ individuum, + + \item ha $x$ $\pi$ fajtájú változó, akkor $|x|^{\mathcal{I},\kappa}$ az $U_{\pi}$-beli $\kappa(x)$ individuum, + + \item ha $t_{1}, t_{2}, ..., t_{k}$ rendre $\pi_{1}, \pi_{2}, ..., \pi_{k}$ fajtájú termek és ezek értékei + a $\kappa$ változókiértékelés mellett rendre az $U_{\pi_{1}}$-beli $|t_{1}|^{\mathcal{I},\kappa}$, az + $U_{\pi_{2}}$-beli $|t_{2}|^{\mathcal{I},\kappa}$ ... és az $U_{\pi_{k}}$-beli $|t_{k}|^{\mathcal{I},\kappa}$ + individuumok, akkor egy $(\pi_{1}, \pi_{2}, ..., \pi_{k}, \pi)$ alakú $f \in Fn$ függvényszimbólum esetén + $|f(t_{1}, t_{2}, ..., t_{k})|^{\mathcal{I},\kappa}$ az $U_{\pi}$-beli + $f^{\mathcal{I}}(|t_{1}|^{\mathcal{I},\kappa}, |t_{2}|^{\mathcal{I},\kappa}, ..., |t_{k}|^{\mathcal{I},\kappa})$ + individuum. + +\end{enumerate} + +\noindent \textbf{Változókiértékelés $x$-variánsa}: Legyen $x$ egy változó. A $\kappa^{*}$ változókiértékelés a +$\kappa$ változókiértékelés $x$-variánsa, ha $\kappa^{*}(y) = y$ minden $x$-től különböző $y$ változó esetén.\\ + +\noindent \textbf{Elsőrendű logikai formula logikai értéke}: +Legyen az $\mathcal{L}[V_{\nu}]$ nyelvnek $\mathcal{I}$ egy interpretációja és $\kappa$ egy $\mathcal{I}$-beli +változókiértékelés. Az $\mathcal{L}[V_{\nu}]$ nyelv egy $C$ formulájához $\mathcal{I}$-ben a $\kappa$ változókiértékelés +mellett az alábbi -- $|C|^{\mathcal{I},\kappa}$-val jelölt -- igazságértéket rendeljük: + +\begin{enumerate} + \item $|P(t_{1}, t_{2}, ..., t_{k})|^{\mathcal{I},\kappa} = \left\{ + \begin{array}{lr} + igaz & : P^{\mathcal{I}}(|t_{1}|^{\mathcal{I},\kappa}, |t_{2}|^{\mathcal{I},\kappa}, ..., |t_{k}|^{\mathcal{I},\kappa}) = igaz \\ + hamis & : kulonben + \end{array} + \right\}$ + + \item $|\neg A|^{\mathcal{I},\kappa}$ legyen $\neg |A|^{\mathcal{I},\kappa}$ + + \item $|A \wedge B|^{\mathcal{I},\kappa}$ legyen $|A|^{\mathcal{I},\kappa} \wedge |B|^{\mathcal{I},\kappa}$ + + \item $|A \vee B|^{\mathcal{I},\kappa}$ legyen $|A|^{\mathcal{I},\kappa} \vee |B|^{\mathcal{I},\kappa}$ + + \item $|A \supset B|^{\mathcal{I},\kappa}$ legyen $|A|^{\mathcal{I},\kappa} \supset |B|^{\mathcal{I},\kappa}$ + + \item $|\forall x A|^{\mathcal{I},\kappa} = \left\{ + \begin{array}{lr} + igaz & : |A|^{\mathcal{I},\kappa^{*}} = igaz \ \kappa \ minden \ \kappa^{*} \ x-variansara \\ + hamis & : kulonben + \end{array} + \right\}$ + + \item $|\exists x A|^{\mathcal{I},\kappa} = \left\{ + \begin{array}{lr} + igaz & : |A|^{\mathcal{I},\kappa^{*}} = igaz \ \kappa \ valamely \ \kappa^{*} \ x-variansara \\ + hamis & : kulonben + \end{array} + \right\}$ + +\end{enumerate} + +\noindent \textbf{Elsőrendű formula kielégíthetősége}: Egy $A$ elsőrendű formula kielégíthető, ha van +olyan $\mathcal{I}$ interpretáció és $\kappa$ változókiértékelés, amelyre $|A|^{\mathcal{I},\kappa} = igaz$ +(ekkor azt mondjuk, hogy az $\mathcal{I}$ interpretáció és $\kappa$ változókiértékelés kielégíti $A$-t), +különben kielégíthetetlen. + +Amennyiben az $A$ formula zárt, igazságértékét egyedül az interpretáció határozza meg. Ha $|A|^{\mathcal{I}} = igaz$, +azt mondjuk, hogy az $\mathcal{I}$ kielégíti $A$-t vagy másképpen: $\mathcal{I}$ modellje $A$-nak ($\mathcal{I} \models A$).\\ + +\noindent \textbf{Logikailag igaz elsőrendű formula}: Egy $A$ elsőrendű logikai formula logikailag igaz, +ha minden $\mathcal{I}$ interpretációban és $\mathcal{I}$ minden $\kappa$ változókiértékelése mellett +$|A|^{\mathcal{I},\kappa} = igaz$. Jelölése: $\models A$.\\ + +\noindent \textbf{Szemantikus következmény}: Azt mondjuk, hogy a $G$ formula \textit{szemantikus következménye} az +$\mathcal{F}$ formulahalmaznak, ha minden olyan $\mathcal{I}$ interpretációra, amelyre $\mathcal{I} \models \mathcal{F}$ +fennáll, $\mathcal{I} \models G$ is igaz (jelölés: $\mathcal{F} \models G$).\\ + +\noindent \textbf{Tétel}: Legyenek $A_{1}, A_{2}, ..., A_{n}, B$ ($n \geq 1$) tetszőleges, ugyanabból az elsőrendű logikai nyelvből +való formulák. Ekkor $\left\{A_{1}, A_{2}, ..., A_{n}\right\} \models B$ akkor és csak akkor, ha +$A_{1} \wedge A_{2} \wedge ... \wedge A_{n} \wedge \neg B$ kielégíthetetlen.\\ + +\noindent \textbf{Rezolúció}: Elsőrendű predikátumkalkulusban is végezhető rezolúció, ráadásul a módszer +helyes és teljes is. Nehézséget a klózok kialakítása okozhat, amelyek zárt, +univerzálisan kvantált literálok konjunkciójából állnak. Ehhez eszközeink a +prenex-, illetve skolem-formák. + +\end{document} \ No newline at end of file diff --git a/12.Logika és számításelmélet/img/igazsagertfa.png b/13. Számításelmélet (és Logika)/img/igazsagertfa.png similarity index 100% rename from 12.Logika és számításelmélet/img/igazsagertfa.png rename to 13. Számításelmélet (és Logika)/img/igazsagertfa.png diff --git a/12.Logika és számításelmélet/img/igazsagertfapelda.png b/13. Számításelmélet (és Logika)/img/igazsagertfapelda.png similarity index 100% rename from 12.Logika és számításelmélet/img/igazsagertfapelda.png rename to 13. Számításelmélet (és Logika)/img/igazsagertfapelda.png diff --git a/12.Logika és számításelmélet/img/kdnf_pelda.png b/13. Számításelmélet (és Logika)/img/kdnf_pelda.png similarity index 100% rename from 12.Logika és számításelmélet/img/kdnf_pelda.png rename to 13. Számításelmélet (és Logika)/img/kdnf_pelda.png diff --git a/12.Logika és számításelmélet/img/kiterjigaztabla.png b/13. Számításelmélet (és Logika)/img/kiterjigaztabla.png similarity index 100% rename from 12.Logika és számításelmélet/img/kiterjigaztabla.png rename to 13. Számításelmélet (és Logika)/img/kiterjigaztabla.png diff --git a/12.Logika és számításelmélet/img/kknf_pelda.png b/13. Számításelmélet (és Logika)/img/kknf_pelda.png similarity index 100% rename from 12.Logika és számításelmélet/img/kknf_pelda.png rename to 13. Számításelmélet (és Logika)/img/kknf_pelda.png diff --git a/12.Logika és számításelmélet/img/rezoluciopelda.png b/13. Számításelmélet (és Logika)/img/rezoluciopelda.png similarity index 100% rename from 12.Logika és számításelmélet/img/rezoluciopelda.png rename to 13. Számításelmélet (és Logika)/img/rezoluciopelda.png diff --git a/12.Logika és számításelmélet/img/rezoluciopelda_levfa.png b/13. Számításelmélet (és Logika)/img/rezoluciopelda_levfa.png similarity index 100% rename from 12.Logika és számításelmélet/img/rezoluciopelda_levfa.png rename to 13. Számításelmélet (és Logika)/img/rezoluciopelda_levfa.png diff --git a/12.Logika és számításelmélet/img/rezolvens.png b/13. Számításelmélet (és Logika)/img/rezolvens.png similarity index 100% rename from 12.Logika és számításelmélet/img/rezolvens.png rename to 13. Számításelmélet (és Logika)/img/rezolvens.png diff --git a/12.Logika és számításelmélet/img/szemantikusfa.png b/13. Számításelmélet (és Logika)/img/szemantikusfa.png similarity index 100% rename from 12.Logika és számításelmélet/img/szemantikusfa.png rename to 13. Számításelmélet (és Logika)/img/szemantikusfa.png diff --git a/12.Logika és számításelmélet/img/szerkfa.png b/13. Számításelmélet (és Logika)/img/szerkfa.png similarity index 100% rename from 12.Logika és számításelmélet/img/szerkfa.png rename to 13. Számításelmélet (és Logika)/img/szerkfa.png diff --git a/12.Logika és számításelmélet/img/turinggep_pelda.png b/13. Számításelmélet (és Logika)/img/turinggep_pelda.png similarity index 100% rename from 12.Logika és számításelmélet/img/turinggep_pelda.png rename to 13. Számításelmélet (és Logika)/img/turinggep_pelda.png diff --git a/14. Alapvető algoritmusok/14. Alapvető algoritmusok.pdf b/14. Alapvető algoritmusok/14. Alapvető algoritmusok.pdf new file mode 100644 index 0000000..9efd2bf Binary files /dev/null and b/14. Alapvető algoritmusok/14. Alapvető algoritmusok.pdf differ diff --git a/14. Alapvető algoritmusok/14. Alapvető algoritmusok.tex b/14. Alapvető algoritmusok/14. Alapvető algoritmusok.tex new file mode 100644 index 0000000..4057803 --- /dev/null +++ b/14. Alapvető algoritmusok/14. Alapvető algoritmusok.tex @@ -0,0 +1,399 @@ +\documentclass[margin=0px]{article} + +\usepackage{listings} +\usepackage[utf8]{inputenc} +\usepackage{graphicx} +\usepackage{float} +\usepackage[a4paper, margin=0.7in]{geometry} +\usepackage{amsthm} +\usepackage{amssymb} +\usepackage{t1enc} +\usepackage{fancyhdr} +\usepackage{setspace} + +\onehalfspacing + +\newenvironment{tetel}[1]{\paragraph{#1 \\}}{} + +\pagestyle{fancy} +\lhead{\it{PTI BSc Záróvizsga tételek}} +\rhead{14. Alapvető algoritmusok} + +\title{\textbf{{\Large ELTE IK - Programtervező Informatikus BSc} \vspace{0.2cm} \\ {\huge Záróvizsga tételek}} \vspace{0.3cm} \\ 14. Alapvető algoritmusok} +\author{} +\date{} + +\begin{document} +\maketitle + +\begin{tetel}{Alapvető algoritmusok és adatszerkezetek} + Függvények aszimptotikus viselkedése, algoritmusok hatékonysága. Összehasonlító rendezések (beszúró, összefésülő, gyors- és kupacrendezés), maximális műveletigény alsó korlátja. Rendezés lineáris időben (bucket, leszámláló és radix rendezés). Adattömörítés (naiv, Huffman, LZW). Mintaillesztés (brute-force, quicksearch, KMP). +\end{tetel} + +\section{Függvények aszimptotikus viselkedése, algoritmusok hatékonysága} +TODO + +\section{Összehasonlító rendező algoritmusok (buborék és beszúró rendezés, ill. verseny, kupac, gyors és összefésülő rendezés)} + +Buborék- és beszúró rendezés klasszikusak, $n^2$-es műveletigényűek, a többi hatékony, $n\log(n)$-es idejűek. + +\subsection{Buborékrendezés} + +A legnagyobb értéket cserékkel a végéig felbuborékozza, ezt minden ciklus végén elhagyjuk. A gyakorlatban nem használják. +\begin{figure}[H] + \centering + \includegraphics[width=0.3\textwidth]{img/Buborekrendezes.png} + \caption{Buborékrendezés} +\end{figure} + +\subsection{Beszúró rendezés} + +Kis $n$-re (kb 30) ez a rendezés a legjobb. \\ +Itt az elemmozgatás mindig 1 értékadás (buborékrendezésnél a csere 3 értékadás). Listára is implementálni lehet, ez esetben a pointereket állítjuk át, az elemek helyben maradnak. \\ +$A[1..j]$ rendezett, $j=1..n$. +\begin{figure}[H] + \centering + \includegraphics[width=0.3\textwidth]{img/Beszurorend.jpg} + \caption{Beszúró rendezés} +\end{figure} + +\subsection{Versenyrendezés} + +Gyakorlatban nem használják. \\ +Teljes bináris fa az alapja, egy versenyfa. Szintfolytonosan ábrázoljuk tömbösen.\\ +\begin{enumerate} + \item A versenyfa kitöltése (a verseny lejátszása). Maximum a gyökérben, ennek kiírása az outputra. + \item $(n-1)$-szer + \begin{itemize} + \item[a)] gyökérben szereplő maximális elem helyének megkeresése a levélszinten és $-\infty$ írása a helyére + \item[b)] az egészet újrajátsszuk (azt az ágat, ahol volt) $\to$ 2. legjobb feljut a gyökérbe + \end{itemize} +\end{enumerate} +\begin{figure}[H] + \centering + \includegraphics[width=0.3\textwidth]{img/Versenyrend.jpg} + \includegraphics[width=0.3\textwidth]{img/VFaKitolt.jpg} + \includegraphics[width=0.3\textwidth]{img/VFaMax.jpg} + \caption{Versenyrendezés} +\end{figure} + +\subsection{Kupacrendezés} + +\begin{enumerate} + \item Kezdő kupac kialakítása. Rendezetlen input tömbből tartalmi invariánst készítünk, ami már kupac struktúrájú. Elv: cserékkel lesüllyesztjük az elemet a nagyobb gyerek irányába, ha kisebb a nagyobbik gyereknél. A süllyesztés eljuthat ahhoz a csúcshoz, amelynek nincs jobb gyereke. + \item $(n-1)$-szer + \begin{itemize} + \item[a)] gyökérelem és az alsó szint jobb szélső (=utolsó) aktív elemének cseréje, és a csere után lekerült elem inaktívvá tétele + \item[b)] a gyökérbe került elem süllyesztése az aktív kupacon + \end{itemize} +\end{enumerate} +\begin{figure}[H] + \centering + \includegraphics[width=0.3\textwidth]{img/Kezdokupac.jpg} + \includegraphics[width=0.3\textwidth]{img/Sully.jpg} + \includegraphics[width=0.3\textwidth]{img/KupacRend.jpg} + \caption{Kupacrendezés} +\end{figure} + +A kezdőkupac kialakításánál, és a ciklus közben a süllyesztés módja kicsit különbözik, hiszen az első esetben a változó elem süllyed le a teljes kupacon, a másodikban a gyökér süllyed az aktív kupacon. A képen látható algoritmus mindkét műveletet teljesíti. + +\subsection{Gyorsrendezés} + +Elve: véletlenül választunk egy elemet. A nála kisebb elemeket tőle balra, a nagyobbakat jobbra rakjuk, az elemet berakjuk a két rész közé. Rekurzív algoritmus. +\begin{figure}[H] + \centering + \includegraphics[width=0.3\textwidth]{img/GyorsRend.jpg} + \includegraphics[width=0.3\textwidth]{img/Helyrevisz.jpg} + \caption{Gyorsrendezés} +\end{figure} + +\subsection{Összefésülő rendezés} + +Alapja: 2 rendezett sorozat összefésülése. Ezt alkalmazhatjuk felülről lefelé (rekurzív) vagy alulról felfelé (iteratív), ez utóbbit szekvenciális fájloknál. +\begin{figure}[H] + \centering + \includegraphics[width=0.3\textwidth]{img/OFRend.jpg} + \caption{Összefésülő rendezés} +\end{figure} + +\section{A műveletigény alsó korlátja összehasonlító rendezésekre} + +\subsection{Műveletigény} + +Kijelöljük a domináns műveleteket, és az $n$ inputméret függvényében hányszor hajtódnak végre, ezt nézzük. Jelölés általánosan $T(n)$, de lehet konkrétan is, pl $Cs(n)$ [csere]. $mT(n)$ a minimális műveletigény, $MT(n)$ a maximális és $AT(n)$ az átlagos. +\begin{itemize} + \item[$\Theta$]: nagyságrendileg azonos, két konstans közé beszorítható + \item[$\mathcal{O}$]: nagyságrendi felső becslés, $o$: nincs megengedve az egyenlőség + \item[$\Omega$]: nagyságrendi alsó becslés, $\omega$: nincs megengedve az egyenlőség +\end{itemize} + +\subsection{Alsókorlát} + +Például: $n$ elem maximumkiválasztása legalább $(n-1)$ összehasonlítást igényel. Bizonyítása: Ha ennél kevesebb összehasonlítás lenne, akkor legalább 1 elem kimaradt, és ezzel ellentmondásba kerülhetünk. \\ +\textit{Döntési fa}: Algoritmus $n$ méretű inputra. Kiegyenesednek a ciklusok véges hosszú lánccá, a végrehajtás nyoma egy fa struktúrát ad. Tökéletes fa: minden belső pontnak 2 gyereke van. Ennél az algoritmusnál nincs jobb, mert $2^{h(t)} \geq n!$, összehasonlító rendezés esetén, $n!$ input. + +\subsection{Alsókorlát legrosszabb esetben} + +Tétel: $MO_R(n) = \Omega(n\log{n})$ A legkedvezőtlenebb permutációra legalább $n\log{n}$ összehasonlítás. Bizonyítás: $\log_2{n!} \leq n\log_2{n} = \Omega(n\log{n})$, és $MO_R(n)=h(t) \geq \log_2{n!}$ (lemma miatt) $\Rightarrow$ $MO_R(n)=\Omega(n\log{n})$. + +\subsection{Alsókorlát átlagos esetben} + +Legyen minden input egyformán valószínű ($\frac{1}{n!}$). \\ +$AO_R(n) = \frac{1}{n!}\sum_{p \in Perm(n)}{O_R(p)}$, és könnyű belátni, hogy $\sum_{p}{O_R(p)} = lhsum(h(t_R(n)))$ [levél-magasság-összeg]. \\ +Lemma: Az $n!$ levelet tartalmazó tökéletes fák közül azokra a legkisebb az $lhsum(h(t_R(n)))$ érték, amelyek majdnem teljesek. \\ +Tétel: $AO_R(n) = \Omega(n\log{n})$. + +\section{Rendezés lineáris időben (bucket-, leszámláló- és radix rendezés)} +TODO + +\section{Adattömörítések} +\subsection{Huffman-algoritmus} +A Huffman-algoritmussal való tömörítés lényege, hogy a gyakrabban előforduló elemeket (karaktereket) rövidebb, míg a ritkábban előfordulókar hosszabb kódszavakkal kódoljuk. + +Ehhez tisztában kell lennünk az egyes karakterek gyakoriságával (vagy relatív gyakoriságával). Ezek alapján egy ún. Huffman-fát építünk, melyben az éleket a kód betűivel címkézzük, a fa levelein a kódolandó betűk helyezkednek el, a gyökérből a levelekig vezető út címkéi alapján rajuk össze a kódszavakat.\\ + +\noindent +Az algoritmus (spec. bináris Huffman fára): +\begin{enumerate} + \item A kódolandó szimbólumokat gyakoriságaik alapján sorba rendezzük. + \item A következő redukciós lépéseket addig hajtjuk végre, míg egy csoportunk marad. + \item Kiválasztjuk az utolsó két elemet (legritkább), összevonjuk őket egy új csoportba, és ennek a csoportnak a gyakorisága a gyakoriságok összege lesz. + \item A csoportot visszahelyezzük a rendezett sorba (gyakoriság alapján rendezve). + \item A csoportból új csúcsot képezünk, mely csúcs az őt alkotó két elem szülője lesz. +\end{enumerate} + +\noindent +Példa:\\ +Legyen a következő 5 betű, mely a megadott gyakorisággal fordul elő:\\ + +\begin{tabular}{|c|c|c|c|c|} + \hline A & B & C & D & E \\ + \hline 5 & 4 & 3 & 2 & 1 \\ + \hline +\end{tabular}\\ + +Ekkor a redukciós lépések a következők: + +\begin{itemize} + \item \begin{tabular}{|c|c|c|c|} + \hline A & B & C & D, E \\ + \hline 5 & 4 & 3 & 3 \\ + \hline + \end{tabular} + + \item \begin{tabular}{|c|c|c|} + \hline C, D, E & A & B \\ + \hline 6 & 5 & 4 \\ + \hline + \end{tabular} + + \item \begin{tabular}{|c|c|} + \hline A , B & C, D, E \\ + \hline 9 & 6 \\ + \hline + \end{tabular} + + \item \begin{tabular}{|c|} + \hline A , B , C, D, E \\ + \hline 15 \\ + \hline + \end{tabular} +\end{itemize} + +A huffman-fa a XY. ábrán látható. + +\begin{figure}[H] + \centering + \includegraphics[width=0.3\textwidth]{img/Huffman_fa.png} + \caption{Huffman-fa példa} + \label{fig:Huffman_fa} +\end{figure} + +Tehát a kódszavak: + +\begin{tabular}{|c|c|c|c|c|} + \hline A & B & C & D & E \\ + \hline 00 & 01 & 10 & 110 & 111 \\ + \hline +\end{tabular} +\subsection{LZW-algoritmus} +Az LZW (Lempel-Ziv-Welch) tömörítésnek a lényege, hogy egy szótárat bővítünk folyamatosan, és az egyes kódolandó szavakhoz szótárindexeket rendelünk. +\begin{description} + \item[Kódolás] \hfill \\ + A kódolás algoritmusa a következő lépésekből áll: + \begin{enumerate} + \item A szótárt inicializáljuk az összes 1 hosszú szóval + \item \label{itm:szotar} Kikeressük a szótárból a leghosszabb, jelenlegi inputtal összeillő $W$ sztringet + \item $W$ szótárindexét kiadjuk, és $W$-t eltávolítjuk az inputról + \item A $W$ szó és az input következő szimbólumának konkatenációját felvesszük a szótárba + \item A \ref{itm:szotar}. lépéstől ismételjük + \end{enumerate} + \item[Dekódolás] \hfill \\ + A dekódolás során is építenünk kell a szótárat. Ezt már azonban csak a dekódolt szöveg(rész) segítségével tudjuk megtenni, mivel egy megkapott kód dekódolt szava és az utána lévő szó első karakteréből áll össze a szótár következő eleme. + + Tehát a dekódolás lépései: + \begin{enumerate} + \item Kikeressük a kapott kódhoz tartozó szót a szótárból ($u$), az output-ra rakjuk + \item Kikeressük a következő szót ($v$) a szótárból, az első szimbólumát $u$-hoz konkatenálva a szótárba rakjuk a következő indexszel. + \item Amennyiben már nincs következő szó, dekódolunk, de nem írunk a szótárba. + \end{enumerate} + + Megtörténhet az az eset, hogy mégis kapunk olyan kódszót, mely még nincs benne a szótárban. Ez akkor fordulhat elő, ha a kódolásnál az aktuálisan szótárba írt szó következik.\\ + + Példa: + + Szöveg: AAA\\ + Szótár: A - 1 + + Ekkor a kódolásnál vesszük az első karaktert, a szótárbeli indexe 1, ezt kiküldjük az outputra. A következő karakter A, így AA-t beírjuk a szótárba 2-es indexszel. Az első karaktert töröljük az inputról. Addig olvasunk, míg szótárbeli egyezést találunk, így AA-t olvassuk (amit pont az előbb raktunk be), ennek indexe 2, tehát ezt küldjük az outputra. AA-t töröljük az inputról, és ezzel végeztünk is. Az output: 1,2 + + Dekódoljuk az 1,2 inputot! Jelenleg a szótárban csak A van 1-es indexszel. Vegyük az input első karakterét, az 1-et, ennek szótárbeli megfelelője A. Ezt tegyük az outputra. A következő index a 2, de ilyen bejegyzés még nem szerepel a szótárban. \\ + + Ebben az esetben a dekódolásnál, egy trükköt vetünk be. A szótárba írás pillanatában még nem ismert a beírandó szó utolsó karaktere (A példában A-t találtuk, de nem volt 2-es bejegyzés). Ekkor ?-et írunk a szótárba írandó szó utolsó karakterének helyére. (Tehát A? - 2 kerül a szótárba). De mostmár tudni lehet az új bejegyzés első betűjét ( A? - 2 az új bejegyzés, ennek első betűje A). Cseréljük le a ?-et erre a betűre. (Tehát AA - 2 lesz a szótárban). +\end{description} +\section{Mintaillesztés} +\subsection{Knuth-Morris-Pratt algoritmus} +A Knuth-Morris-Pratt eljárásnak a Brute-Force (hasonlítsuk össze, toljunk egyet, stb..) módszerrel szemben az az előnye, hogy egyes esetekben, ha a mintában vannak ismétlődő elemek, akkor egy tolásnál akár több karakternyit is ugorhatunk. + +\begin{figure}[H] + \centering + \includegraphics[width=0.4\textwidth]{img/KMP_sample.png} + \caption{KMP algoritmus több karakter tolás estén} + \label{fig:KMP_sample} +\end{figure} + +Az ugrás megállapítását a következőképp tesszük: Az eddig megvizsgált egyező mintarész elején (prefix) és végén (suffix) olyan kartersorozatot keresünk, melyek megegyeznek. Ha találunk ilyet, akkor a mintát annyival tolhatjuk, hogy az elején lévő része ráilleszkedjen a végén levőre. + +Azt, hogy ez egyes esetekben mekkorát tolhatunk nem kell minden elromlás alkalmával vizsgálni. Ha a mintára önmagával lefuttatjuk az algoritmus egy módosított változatát (\ref{fig:KMP_initnext}. ábra), kitölthetünk egy tömböt, mely alapján a tolásokat végezni fogjuk. + +\begin{figure}[H] + \centering + \includegraphics[width=0.3\textwidth]{img/KMP_initnext.jpg} + \caption{KMP tolásokat szabályzó tömb kitöltése} + \label{fig:KMP_initnext} +\end{figure} + +Az algoritmus (ld \ref{fig:KMP}. ábra): +\begin{itemize} + \item Két indexet $i$ és $j$ futtatunk a szövegen illetve a mintán. + \item Ha az $i+1$-edik és $j+1$-edik karakterek megegyeznek, akkor léptetjük mind a kettőt. + \item Ha nem egyeznek meg, akkor: + \begin{itemize} + \item Ha a minta első elemét vizsgáltuk, akkor egyet tolunk a mintán, magyarul a minta indexe marad az első betűn, és a szövegben lévő indexet növeljük eggyel ($i=i+1$) + \item Ha nem a minta első elemét vizsgáltuk, akkor annyit tolunk, amennyit szabad. Ez azt jelenti, hogy csak a mintán lévő indexet helyezzük egy kisebb helyre ($j = next[j]$) + \end{itemize} + \item Addig megyünk, míg vagy a minta, vagy a szöveg végére nem érünk. Ha a minta végére értünk, akkor megtaláltuk a mintát a szövegben, ha a szöveg végére értünk, akkor pedig nem. +\end{itemize} + +\begin{figure}[H] + \centering + \includegraphics[width=0.3\textwidth]{img/KMP.jpg} + \caption{KMP algoritmus} + \label{fig:KMP} +\end{figure} +\subsection{Boyer-Moore | Quick search algoritmus} +Míg a KMP algoritmus az elromlás helye előtti rész alapján döntött a tolásról, addig a QS a minta utáni karakter alapján. Tehát elromlás esetén: +\begin{itemize} + \item Ha a minta utáni karakter benne van a mintában, akkor jobbról az első előfordulására illesztjük. (\ref{fig:BoyerMoore_shift1}. ábra) + \begin{figure}[H] + \centering + \includegraphics[width=0.4\textwidth]{img/BoyerMoore_shift1.png} + \caption{QS - eltolás ha a minta utáni karakter benne van a mintában} + \label{fig:BoyerMoore_shift1} + \end{figure} + \item Ha a minta utáni karakter nincs benne a mintában, akkor a mintát ezen karakter után illesztjük. (\ref{fig:BoyerMoore_shift2}. ábra) + \begin{figure}[H] + \centering + \includegraphics[width=0.6\textwidth]{img/BoyerMoore_shift2.png} + \caption{QS - eltolás ha a minta utáni karakter nincs benne a mintában} + \label{fig:BoyerMoore_shift2} + \end{figure} +\end{itemize} + +Az eltolás kiszámítását megint elő lehet segíteni egy tömbbel, most azonban, mivel nem a minta az érdekes, és nem tudjuk pontosan mely karakterek szerepelnek a szövegben, így a tömbbe az egész abc-t fel kell vennünk (\ref{fig:BoyerMoore_initshift}. ábra) + +\begin{figure}[H] + \centering + \includegraphics[width=0.3\textwidth]{img/BoyerMoore_initshift.jpg} + \caption{QS - Az eltolást elősegítő tömb ($Shift['a'...'z']$) konstruálása} + \label{fig:BoyerMoore_initshift} +\end{figure} + +Az algoritmus (ld. \ref{fig:BoyerMoore}. ábra): +\begin{itemize} + \item Két indexet $k$ és $j$ futtatunk a szövegen illetve a mintán. + \item Ha a szöveg $k+j$-edik eleme megegyezik a minta $j$-edik karakterével, akkor léptetjük $j$-t (mivel a szövegben $k+j$-edik elemet nézzük, így elég $j$-t növelni). + \item Ha nem egyeznek meg, akkor: + \begin{itemize} + \item Ha a minta már a szöveg végén van ($k=n-m$), akkor csak növeljük $k$-t eggyel, ami hamissá teszi a ciklus feltételt. + \item Ha még nem vagyunk a szöveg végén $k$-t toljuk annyival, amennyivel lehet (ezt az előre beállított $Shift$ tömb határozza meg). És a $j$-t visszaállítjuk 1-re. + \end{itemize} + \item Addig megyünk, míg vagy a minta végére érünk $j$-vel, vagy a mintát továbbtoltuk a szöveg végénél. Előbbi esetben egyezést találtunk, míg az utóbbiban nem. +\end{itemize} + +\begin{figure}[H] + \centering + \includegraphics[width=0.4\textwidth]{img/BoyerMoore.jpg} + \caption{QS} + \label{fig:BoyerMoore} +\end{figure} +\subsection{Rabin-Karp algoritmus} +A Rabin-Karp algoritmus lényege, hogy minden betűhöz az ábécéből egy számjegyet rendelünk, és a keresést számok összehasonlításával végezzük. Világos, hogy ehhez egy ábécé méretnek megfelelő számrendszerre lesz szükségünk. A szövegből mindig a minta hosszával egyező részeket szelünk ki, és ezeket hasonlítjuk össze.\\ + +\noindent +Példa:\\ +Minta: BBAC $\rightarrow$ 1102 \\ +Szöveg: DACABBAC $\rightarrow$ 30201102, amiből a következő számokat állítjuk elő: 3020, 0201, 2011, 0110, 1102\\ + +\noindent +A fent látható szeletek lesznek az $s_i$-k.\\ + +\noindent +Az algoritmus működéséhez azonban számos apró ötletet alkalmazunk: +\begin{enumerate} + \item A minta számokká alakítását Horner-módszer segítségével végezzük. + \begin{figure}[H] + \centering + \includegraphics[width=0.3\textwidth]{img/RK_Horner.jpg} + \caption{RK - Horner-módszer} + \label{fig:RK_Horner} + \end{figure} + Az $ord()$ függvény az egyes betűknek megfelelő számot adja vissza. A $d$ a számrendszer alapszáma. + \item A szöveg mintával megegyező hosszú szeleteinek ($s_i$) előállítása: \\ + $s_0$-t a Horner-módszerrel ki tudjuk számolni. Ezek után $s_{i+1}$ a következőképp számolandó: + \[s_{i+1} = (s_i - ord(S[i])\cdot d^{m-1})\cdot d + ord(S[i+1])\] + \textit{Magyarázat: $s_i$ elejéről levágjuk az első számjegyet ($s_i - ord(S[i])\cdot d^{m-1}$), majd a maradékot eltoljuk egy helyiértékkel (szorzás $d$-vel), végül az utolsó helyiértékre beírjuk a következő betűnek megfelelő számjegyet ($+ord(S[i+1])$)} + + Példa: + + Az előző példa szövegével és mintájával ($d=10$ elemű ábécé és $m=4$ hosszú minta): \\ + $s_0 = 3020$, ekkor: $s_{0+1} = s_1 = (3020 - ord(D) \cdot 10^3)\cdot 10 + ord(B) = (3020-3000)\cdot 10 +1 = 0201$ + \item Felmerülhet a kérdés, hogy az ilyen magas alapszámú számrendszerek nem okoznak-e gondot az ábrázolásnál? A kérdés jogos. Vegyük a következő életszerű példát: + + 4 bájton ábrázoljuk a számainkat ($2^{32}$). Az abc legyen 32 elemű ($d=32$), a minta 8 hosszú ($m=8$). Ekkor a $d^{m-1}$ kiszámítása: $32^7 = (2^5)^7 = 2^{35}$ , ami már nem ábrázolható 4 bájton. + + Ennek kiküszöbölésére vezessünk be egy nagy $p$ prímet, melyre $d\cdot p$ még ábrázolható. És a műveleteket számoljuk {\it mod p}. Ekkor természetesen a kongruencia miatt lesz olyan eset, amikor az algoritmus egyezést mutat, mikor valójában nincs. Ez nem okoz gondot, mivel ilyen esetben karakterenkénti egyezést vizsgálva ezt a problémát kezelni tudjuk. (Fordított eset nem fordul elő tehát nem lesz olyan eset, mikor karakterenkénti egyezés van, de numerikus nincs). [Ha $p$ kellően nagy, a jelenség nagyon ritkán fordul elő.] + + \item A {\it mod p} számítás egy másik problémát is felvet. Ugyanis a kivonás alkalmával negatív számokat is kaphatunk. + + Például: Legyen $p=7$, ekkor, ha $ord(S[i]) = 9$, akkor előző számítás után $s_i = 2...$, de ebből $ord(S[i])\cdot d^{m-1} = 9\cdot 10^3 = 9000$-et vonunk ki negatív számot kapunk. + + Megoldásként $s_{i+1}$-et két lépésben számoljuk: + \[s := (s_i+d\cdot p - ord(S[i])\cdot d^{m-1}) \quad mod \quad p \] + \[s_{i+1} := (s\cdot d + ord(S[i+1])) \quad mod \quad p \] +\end{enumerate} +A fentiek alapján az algoritmus a következő (ld. \ref{fig:RK}. ábra) +\begin{enumerate} + \item Kiszámoljuk $d^{m-1}$-et ($dm1$) + \item Egy iterációban meghatározzuk Horner-módszerrel a minta számait ($x$) és $s_0$-t + \item Ellenőrizzük, hogy egyeznek-e + \item Addig számolgatjuk $s_i$ értékét míg a minta nem egyezik $s_i$-vel, vagy a minta a szöveg végére nem ért. +\end{enumerate} +\begin{figure}[H] + \centering + \includegraphics[width=0.3\textwidth]{img/RK.jpg} + \caption{RK} + \label{fig:RK} +\end{figure} + +\end{document} \ No newline at end of file diff --git a/13.Alapvető algoritmusok és adatszerkezetek/img/Beszurorend.jpg b/14. Alapvető algoritmusok/img/Beszurorend.jpg similarity index 100% rename from 13.Alapvető algoritmusok és adatszerkezetek/img/Beszurorend.jpg rename to 14. Alapvető algoritmusok/img/Beszurorend.jpg diff --git a/14.Haladó algoritmusok/img/BoyerMoore.jpg b/14. Alapvető algoritmusok/img/BoyerMoore.jpg similarity index 100% rename from 14.Haladó algoritmusok/img/BoyerMoore.jpg rename to 14. Alapvető algoritmusok/img/BoyerMoore.jpg diff --git a/14.Haladó algoritmusok/img/BoyerMoore_initshift.jpg b/14. Alapvető algoritmusok/img/BoyerMoore_initshift.jpg similarity index 100% rename from 14.Haladó algoritmusok/img/BoyerMoore_initshift.jpg rename to 14. Alapvető algoritmusok/img/BoyerMoore_initshift.jpg diff --git a/14.Haladó algoritmusok/img/BoyerMoore_shift1.png b/14. Alapvető algoritmusok/img/BoyerMoore_shift1.png similarity index 100% rename from 14.Haladó algoritmusok/img/BoyerMoore_shift1.png rename to 14. Alapvető algoritmusok/img/BoyerMoore_shift1.png diff --git a/14.Haladó algoritmusok/img/BoyerMoore_shift2.png b/14. Alapvető algoritmusok/img/BoyerMoore_shift2.png similarity index 100% rename from 14.Haladó algoritmusok/img/BoyerMoore_shift2.png rename to 14. Alapvető algoritmusok/img/BoyerMoore_shift2.png diff --git a/13.Alapvető algoritmusok és adatszerkezetek/img/Buborekrendezes.png b/14. Alapvető algoritmusok/img/Buborekrendezes.png similarity index 100% rename from 13.Alapvető algoritmusok és adatszerkezetek/img/Buborekrendezes.png rename to 14. Alapvető algoritmusok/img/Buborekrendezes.png diff --git a/13.Alapvető algoritmusok és adatszerkezetek/img/GyorsRend.jpg b/14. Alapvető algoritmusok/img/GyorsRend.jpg similarity index 100% rename from 13.Alapvető algoritmusok és adatszerkezetek/img/GyorsRend.jpg rename to 14. Alapvető algoritmusok/img/GyorsRend.jpg diff --git a/13.Alapvető algoritmusok és adatszerkezetek/img/Helyrevisz.jpg b/14. Alapvető algoritmusok/img/Helyrevisz.jpg similarity index 100% rename from 13.Alapvető algoritmusok és adatszerkezetek/img/Helyrevisz.jpg rename to 14. Alapvető algoritmusok/img/Helyrevisz.jpg diff --git a/14.Haladó algoritmusok/img/Huffman_fa.png b/14. Alapvető algoritmusok/img/Huffman_fa.png similarity index 100% rename from 14.Haladó algoritmusok/img/Huffman_fa.png rename to 14. Alapvető algoritmusok/img/Huffman_fa.png diff --git a/14.Haladó algoritmusok/img/KMP.jpg b/14. Alapvető algoritmusok/img/KMP.jpg similarity index 100% rename from 14.Haladó algoritmusok/img/KMP.jpg rename to 14. Alapvető algoritmusok/img/KMP.jpg diff --git a/14.Haladó algoritmusok/img/KMP_initnext.jpg b/14. Alapvető algoritmusok/img/KMP_initnext.jpg similarity index 100% rename from 14.Haladó algoritmusok/img/KMP_initnext.jpg rename to 14. Alapvető algoritmusok/img/KMP_initnext.jpg diff --git a/14.Haladó algoritmusok/img/KMP_sample.png b/14. Alapvető algoritmusok/img/KMP_sample.png similarity index 100% rename from 14.Haladó algoritmusok/img/KMP_sample.png rename to 14. Alapvető algoritmusok/img/KMP_sample.png diff --git a/13.Alapvető algoritmusok és adatszerkezetek/img/Kezdokupac.jpg b/14. Alapvető algoritmusok/img/Kezdokupac.jpg similarity index 100% rename from 13.Alapvető algoritmusok és adatszerkezetek/img/Kezdokupac.jpg rename to 14. Alapvető algoritmusok/img/Kezdokupac.jpg diff --git a/13.Alapvető algoritmusok és adatszerkezetek/img/Kupacrend.jpg b/14. Alapvető algoritmusok/img/Kupacrend.jpg similarity index 100% rename from 13.Alapvető algoritmusok és adatszerkezetek/img/Kupacrend.jpg rename to 14. Alapvető algoritmusok/img/Kupacrend.jpg diff --git a/13.Alapvető algoritmusok és adatszerkezetek/img/OfRend.jpg b/14. Alapvető algoritmusok/img/OfRend.jpg similarity index 100% rename from 13.Alapvető algoritmusok és adatszerkezetek/img/OfRend.jpg rename to 14. Alapvető algoritmusok/img/OfRend.jpg diff --git a/14.Haladó algoritmusok/img/RK.jpg b/14. Alapvető algoritmusok/img/RK.jpg similarity index 100% rename from 14.Haladó algoritmusok/img/RK.jpg rename to 14. Alapvető algoritmusok/img/RK.jpg diff --git a/14.Haladó algoritmusok/img/RK_Horner.jpg b/14. Alapvető algoritmusok/img/RK_Horner.jpg similarity index 100% rename from 14.Haladó algoritmusok/img/RK_Horner.jpg rename to 14. Alapvető algoritmusok/img/RK_Horner.jpg diff --git a/13.Alapvető algoritmusok és adatszerkezetek/img/Sully.jpg b/14. Alapvető algoritmusok/img/Sully.jpg similarity index 100% rename from 13.Alapvető algoritmusok és adatszerkezetek/img/Sully.jpg rename to 14. Alapvető algoritmusok/img/Sully.jpg diff --git a/13.Alapvető algoritmusok és adatszerkezetek/img/VFaKitolt.jpg b/14. Alapvető algoritmusok/img/VFaKitolt.jpg similarity index 100% rename from 13.Alapvető algoritmusok és adatszerkezetek/img/VFaKitolt.jpg rename to 14. Alapvető algoritmusok/img/VFaKitolt.jpg diff --git a/13.Alapvető algoritmusok és adatszerkezetek/img/VFaMax.jpg b/14. Alapvető algoritmusok/img/VFaMax.jpg similarity index 100% rename from 13.Alapvető algoritmusok és adatszerkezetek/img/VFaMax.jpg rename to 14. Alapvető algoritmusok/img/VFaMax.jpg diff --git a/13.Alapvető algoritmusok és adatszerkezetek/img/Versenyrend.jpg b/14. Alapvető algoritmusok/img/Versenyrend.jpg similarity index 100% rename from 13.Alapvető algoritmusok és adatszerkezetek/img/Versenyrend.jpg rename to 14. Alapvető algoritmusok/img/Versenyrend.jpg diff --git a/15. Adatszerkezetek és adattípusok/15. Adatszerkezetek és adattípusok.pdf b/15. Adatszerkezetek és adattípusok/15. Adatszerkezetek és adattípusok.pdf new file mode 100644 index 0000000..3603a9e Binary files /dev/null and b/15. Adatszerkezetek és adattípusok/15. Adatszerkezetek és adattípusok.pdf differ diff --git a/15. Adatszerkezetek és adattípusok/15. Adatszerkezetek és adattípusok.tex b/15. Adatszerkezetek és adattípusok/15. Adatszerkezetek és adattípusok.tex new file mode 100644 index 0000000..0b2e18c --- /dev/null +++ b/15. Adatszerkezetek és adattípusok/15. Adatszerkezetek és adattípusok.tex @@ -0,0 +1,164 @@ +\documentclass[margin=0px]{article} + +\usepackage{listings} +\usepackage[utf8]{inputenc} +\usepackage{graphicx} +\usepackage{float} +\usepackage[a4paper, margin=0.7in]{geometry} +\usepackage{amsthm} +\usepackage{amssymb} +\usepackage{t1enc} +\usepackage{fancyhdr} +\usepackage{setspace} + +\onehalfspacing + +\newenvironment{tetel}[1]{\paragraph{#1 \\}}{} + +\pagestyle{fancy} +\lhead{\it{PTI BSc Záróvizsga tételek}} +\rhead{15. Adatszerkezetek és adattípusok} + +\title{\textbf{{\Large ELTE IK - Programtervező Informatikus BSc} \vspace{0.2cm} \\ {\huge Záróvizsga tételek}} \vspace{0.3cm} \\ 15. Adatszerkezetek és adattípusok} +\author{} +\date{} + +\begin{document} +\maketitle + +\begin{tetel}{Adatszerkezetek és adattípusok} + Tömb, verem, sor, láncolt listák; bináris fa, általános fa, bejárások, ábrázolások; bináris kupac, prioritásos sor; bináris kereső fa és műveletei, AVL fa, B+ fa; hasító táblák, hasító függvények, kulcsütközés és feloldásai: láncolással, nyílt címzéssel, próbasorozat; gráfok ábrázolásai. +\end{tetel} + +\section{Egyszerű adattípusok ábrázolásai, műveletei és fontosabb alkalmazásai} + +\subsection{Adattípus} + +\textit{Adatszerkezet}: $\sim$ struktúra. \\ +\textit{Adattípus}: adatszerkezet és a hozzá tartozó műveletek. \\ +\textit{Adatszerkezetek}: +\begin{itemize} + \item \textit{Tömb}: azonos típusú elemek sorozata, fix méretű. + \item \textit{Verem}: Mindig a verem tetejére rakjuk a következő elemet, csak a legfelsőt kérdezhetjük le, és vehetjük ki. + \begin{figure}[H] + \centering + \includegraphics[width=0.3\textwidth]{img/Verembe.jpg} + \includegraphics[width=0.3\textwidth]{img/Verembol.jpg} + \caption{Verem műveletei} + \end{figure} + \item \textit{Sor}: Egyszerű, elsőbbségi és kétvégű. A prioritásos sornál az elemekhez tartozik egy érték, ami alapján rendezhetjük őket. + \begin{figure}[H] + \centering + \includegraphics[width=0.3\textwidth]{img/Sorba.jpg} + \includegraphics[width=0.3\textwidth]{img/Sorbol.jpg} + \caption{Sor műveletei} + \end{figure} + \item \textit{Lista}: Láncolt ábrázolással reprezentáljuk. 3 szempont szerint különböztethetjük meg a listákat: fejelem van/nincs, láncolás iránya egy/kettő, ciklusosság van/nincs. Ha fejelemes a listánk, akkor a fejelem akkor is létezik, ha üres a lista. \\ + A lista node-okból áll, minden node-nak van egy, a következőre mutató pointere, illetve lehet az előzőre is, ha kétirányú. Ezen kívül van egy első és egy aktuális node-ra mutató pointer is, és az utolsó elem mutatója NIL. A listát megvalósíthatjuk úgy, hogy tetszőleges helyre lehessen elemet beszúrni, illetve törölni. + \begin{figure}[H] + \centering + \includegraphics[width=0.3\textwidth]{img/Listaba.jpg} + \includegraphics[width=0.3\textwidth]{img/Torol.jpg} + \caption{Lista műveletei} + \end{figure} + \item \textit{Fa}: Egyszerű, bináris és speciális (kupac, bináris keresőfa, AVL-fa). A bináris fát rekurzívan definiáljuk: $t \in T(E)$ [bin. fák típusérték halmaza(alaptípus)] $\iff$ $t$ üres fa (jele: $\Omega$), vagy $t$-nek van gyökéreleme, $bal(t)$, $jobb(t)$ részfája. Láncoltan ábrázoljuk, tömbösen csak teljes fák, illetve kupac esetén. + \item \textit{Kupac}: Olyan bináris fa, melynek alakja majdnem teljes és balra rendezett. Tömbösen ábrázoljuk, mert pointeresen a bonyolult lépkedést nem teszi lehetővé, tömbösen indexösszefüggésekkel könnyen megoldható. + \begin{figure}[H] + \centering + \includegraphics[width=0.3\textwidth]{img/KupacbaBeszur.jpg} + \caption{Kupac műveletei} + \end{figure} + \item \textit{Hasítótábla} + \item \textit{Gráf} [Nem egyszerű adattípus.] +\end{itemize} + +\subsection{Ábrázolásai} + +Absztrakciós szintek: +\begin{enumerate} + \item \textit{absztrakt adattípus (ADT)}: specifikáció szintje, itt nincs szerkezeti összefüggés, csak matematikai fogalmak, műveletek logikai axiómákkal vagy előfeltételekkel. + \begin{itemize} + \item algebrai (axiomatikus) specifikáció, példa: $Verembe : V \times E \to V$. Axióma, példa: $Felso(Verembe(v,e)) = e$ + \item funkcionális (elő- és utófeltételes) specifikáció, példa: (elsőbbségi) sor $S(E), s \in S$ egy konkrét sor, $s = \{(e_1, t_1), ..., (e_n, t_n)\}$, $n \geq 0$. Ha $n=0$, akkor a sor üres. \\ + $\forall i,j \in [1..n]: i \neq j \to t_i \neq t_j$. \\ + $Sorbol: S \to S \times E$, $\mathcal{D}_{Sorbol} = S \backslash \{ures\}$. Előfeltétel: $Q = (s = s' \wedge s' \neq \emptyset)$, utófeltétel: $R = (s = s' \backslash \{(e,t)\} \wedge (e,t) \in s' \wedge \forall i (e_i, t_i) \in s' : t \leq t_i)$. + \end{itemize} + \item \textit{absztrakt adatszerkezet (ADS)}: kognitív pszichológia szintje, ábrák. Az alapvető szerkezeti tulajdonságokat tartalmazza (nem mindet). Ennek a szintnek is része a műveletek halmaza. Példák: az ábra egy irányított gráf, művelet magyarázata, adatszerkezet definiálása. + \begin{figure}[H] + \centering + \includegraphics[width=1\textwidth]{img/ads.png} + \caption{ADS} + \end{figure} + \item \textit{ábrázolás/reprezentáció}: döntések (tömbös vagy pointeres ábrázolás), a nyitva hagyott szerkezeti kérdések. Egy adatszerkezetet többféle reprezentációval is meg lehet valósítani (pl. prioritásos sor lehet rendezetlen tömb, rendezett tömb, kupac). + \begin{itemize} + \item \textit{tömbös ábrázolás}: takarékos ábrázolás, elhelyezése, tetszőleges rákövetkezések, bejárások, de ezeket meg kell adni. + \item \textit{pointeres ábrázolás}: minden pointer egy összetett rekord elejére mutat. + \end{itemize} + \item \textit{implementálás} + \item \textit{fizikai szint} +\end{enumerate} + +\subsection{Műveletei} + +\begin{itemize} + \item Üres adatszerkezet létrehozása + \item Annak lekérdezése, hogy üres-e az adatszerkezet + \item Elem berakása, itt ellenőrizni kell, hogy nem telt-e még meg + \item Elem kivétele vagy törlése, itt ellenőrizni kell, hogy nem üres-e + \item Adott tulajdonságú elem (például maximum, veremben a felső) lekérdezése, itt is ellenőrizni kell, hogy üres-e az adatszerkezet + \item Bejárások (preorder, inorder, postorder, szintfolytonos), listáknál az első, előző vagy következő elemre lépés + \item Elem módosítása bizonyos adatszerkezeteknél (pl. listák) +\end{itemize} + +\subsection{Fontosabb alkalmazásai} + +\textit{Prioritásos sor}: nagygépes programfuttatásnál az erőforrásokat a prioritás arányában osszuk el, adott pillanatban a maximális prioritásút válasszuk. Sürgősségi ügyeleten, gráfalgoritmusoknál is alkalmazható. +\textit{B-fa}: ipari méretekben adatbázisokban használják. + +\section{A hatékony adattárolás és visszakeresés néhány megvalósítása (bináris keresőfa, AVL-fa, 2-3-fa és B-fa, hasítás (,,hash-elés”))} + +\subsection{Bináris keresőfa} + +Nincsenek benne azonos kulcsok, a követendő elv: ,,kisebb balra, nagyobb jobbra". Inorder bejárással növekvő kulcssorozatot kapunk. \\ +Műveletigénye fa magasságú nagyságrendű. \\ +Az a cél, hogy a bináris keresőfa ne nyúljon meg láncszerűen, erre jó az AVL-fa és a 2-3-fa. +\begin{figure}[H] + \centering + \includegraphics[width=0.3\textwidth]{img/Beszur.jpg} + \includegraphics[width=0.3\textwidth]{img/Kovetkezo.jpg} + \caption{Bináris keresőfa műveletei} +\end{figure} + +\subsection{AVL-fa} + +Cél: a $t$ bináris keresőfa magasságának $\log_2(n)$ közelében tartása, azaz $h(t) \leq c \cdot \log_2(n)$, ahol $c$ elfogadhatóan kicsi. Az ilyen fát kiegyensúlyozottnak nevezzük. \\ +\textit{AVL}: Adelszon-Velszkij, Landisz 1962-ben alkották meg. \\ +A $t$ bináris keresőfát egyúttal AVL-fának nevezzük $\iff$ $t$ minden $x$ csúcsára $|h(bal(x))-h(jobb(x))| \leq 1$. \\ +Minden csúcsnak van egy címkéje $+,-,=$ (gyerekek magasságának különbsége). A beszúrás helyétől felfelé ellenőrizzük ezeket, és ha kell, akkor módosítjuk. Ha valahol $++$ vagy $--$ alakul ki, akkor ott elromlik az AVL-tulajdonság, egy vagy több forgatással vagy átkötéssel konstans műveletigénnyel helyre lehet hozni. \\ +Többféle séma is van: $(++,+), (++,-), (++,=)$ és a tükörképeik. + +\subsection{2-3-fa és B-fa} + +2-3-fa kis méretben az elmélet számára jó, a B-fa a gyakorlati változat adatbázisban. \\ +$t$ 2-3-fa $\iff$ minden belső csúcsnak 2 vagy 3 gyereke van, a levelek azonos szinten helyezkednek el, adatrekordok csak a levelekben vannak, belső pontokban kulcsok és mutatók, levelekben a kulcsok balról jobbra nőnek. \\ +Ha 4 gyerek lenne a beszúrás után, akkor csúcsot kell vágni. Ha törlésnél 1 gyerek lenne valahol, akkor csúcsösszevonásokat és gyerekátadást alkalmazunk. \\ +B-fa nagyobb méretű, itt két határ között mozog a gyerekszám: $\lceil\frac{r}{2}\rceil$ és $r$, ahol $50 \leq r \leq 1000$. + +\subsection{Hasítás} + +Kulcsos rekordokat tárol. +\begin{itemize} + \item \textit{Hasítás láncolással}: a kulcsütközést láncolással oldja fel. Van egy hasítófüggvény: $h: U \to [0..m-1]$, elvárás vele kapcsolatban, hogy gyorsan számolható és egyenletes legyen. $m$-et úgy választjuk meg $n$ nagyságrendjének ismeretében, hogy $\alpha = \frac{n}{m}$ lesz a várható listahossz, ha egyenletes hasítást feltételezünk.\\ + Például kétirányú listát használhatunk a hasításhoz. Műveletek: beszúrás, keresés, törlés. \\ + Gyakorlatban érdemes $m$-et úgy megválasztani, hogy olyan prímszám legyen, ami nem esik 2-hatvány közelébe. + \item \textit{Hasítás nyitott/nyílt címzéssel}: A kulcsokat lehessen egészként értelmezni, ekkor vannak jó hasítófüggvények. \\ + Próbálkozás általános képlete: $h(k) + h_i(k)$ $(mod$ $M)$, $0 \leq i \leq M-1$. Egész addig alkalmazza, amíg üres helyet nem talál. + \begin{enumerate} + \item \textit{Lineáris próba}: $h_i(k) = -i$ $(mod$ $M)$, egyesével balra lépegetve keressük az üres helyet. Hátránya az elsődleges csomósodás, ez jelentős lassulást okoz beszúrásnál és keresésnél. + \item \textit{Négyzetes próba}: $h_i(k) = (-1)^i(\lceil\frac{i}{2}\rceil)^2$ $(mod$ $M)$, a négyzetszámokkal lépegetünk balra-jobbra, ezek az eltolások kiadják $\{0,1,...,M-1\}$-et. Hátrány: másodlagos csomósodás. + \item \textit{Kettős hash-elés}: $h_i(k) =-ih'(k)$ $(mod$ $M)$, $h'(k)$ a $k$-hoz tartozó egyedi lépésköz, $(h'(k),M)=1$ relatív prímek. Ha az $M$ elég nagy, akkor nincs csomósodás. + \end{enumerate} + \item \textit{Hasítófüggvények}: Leggyakoribb: $k$ egész, kongruencia reláció. Általánosan: $h(k) = (ak +b$ $(mod$ $p))$ $(mod$ $M)$, az univerzális hasítás családja. Tapasztalat: $k$ egyenletesen hasít. +\end{itemize} + +\end{document} \ No newline at end of file diff --git a/13.Alapvető algoritmusok és adatszerkezetek/img/Beszur.jpg b/15. Adatszerkezetek és adattípusok/img/Beszur.jpg similarity index 100% rename from 13.Alapvető algoritmusok és adatszerkezetek/img/Beszur.jpg rename to 15. Adatszerkezetek és adattípusok/img/Beszur.jpg diff --git a/13.Alapvető algoritmusok és adatszerkezetek/img/Kovetkezo.jpg b/15. Adatszerkezetek és adattípusok/img/Kovetkezo.jpg similarity index 100% rename from 13.Alapvető algoritmusok és adatszerkezetek/img/Kovetkezo.jpg rename to 15. Adatszerkezetek és adattípusok/img/Kovetkezo.jpg diff --git a/13.Alapvető algoritmusok és adatszerkezetek/img/KupacbaBeszur.jpg b/15. Adatszerkezetek és adattípusok/img/KupacbaBeszur.jpg similarity index 100% rename from 13.Alapvető algoritmusok és adatszerkezetek/img/KupacbaBeszur.jpg rename to 15. Adatszerkezetek és adattípusok/img/KupacbaBeszur.jpg diff --git a/13.Alapvető algoritmusok és adatszerkezetek/img/Listaba.jpg b/15. Adatszerkezetek és adattípusok/img/Listaba.jpg similarity index 100% rename from 13.Alapvető algoritmusok és adatszerkezetek/img/Listaba.jpg rename to 15. Adatszerkezetek és adattípusok/img/Listaba.jpg diff --git a/13.Alapvető algoritmusok és adatszerkezetek/img/Sorba.jpg b/15. Adatszerkezetek és adattípusok/img/Sorba.jpg similarity index 100% rename from 13.Alapvető algoritmusok és adatszerkezetek/img/Sorba.jpg rename to 15. Adatszerkezetek és adattípusok/img/Sorba.jpg diff --git a/13.Alapvető algoritmusok és adatszerkezetek/img/Sorbol.jpg b/15. Adatszerkezetek és adattípusok/img/Sorbol.jpg similarity index 100% rename from 13.Alapvető algoritmusok és adatszerkezetek/img/Sorbol.jpg rename to 15. Adatszerkezetek és adattípusok/img/Sorbol.jpg diff --git a/13.Alapvető algoritmusok és adatszerkezetek/img/Torol.jpg b/15. Adatszerkezetek és adattípusok/img/Torol.jpg similarity index 100% rename from 13.Alapvető algoritmusok és adatszerkezetek/img/Torol.jpg rename to 15. Adatszerkezetek és adattípusok/img/Torol.jpg diff --git a/13.Alapvető algoritmusok és adatszerkezetek/img/Verembe.jpg b/15. Adatszerkezetek és adattípusok/img/Verembe.jpg similarity index 100% rename from 13.Alapvető algoritmusok és adatszerkezetek/img/Verembe.jpg rename to 15. Adatszerkezetek és adattípusok/img/Verembe.jpg diff --git a/13.Alapvető algoritmusok és adatszerkezetek/img/Verembol.jpg b/15. Adatszerkezetek és adattípusok/img/Verembol.jpg similarity index 100% rename from 13.Alapvető algoritmusok és adatszerkezetek/img/Verembol.jpg rename to 15. Adatszerkezetek és adattípusok/img/Verembol.jpg diff --git a/13.Alapvető algoritmusok és adatszerkezetek/img/ads.png b/15. Adatszerkezetek és adattípusok/img/ads.png similarity index 100% rename from 13.Alapvető algoritmusok és adatszerkezetek/img/ads.png rename to 15. Adatszerkezetek és adattípusok/img/ads.png diff --git a/16. Haladó algoritmusok/16. Haladó algoritmusok.pdf b/16. Haladó algoritmusok/16. Haladó algoritmusok.pdf new file mode 100644 index 0000000..53aa064 Binary files /dev/null and b/16. Haladó algoritmusok/16. Haladó algoritmusok.pdf differ diff --git a/16. Haladó algoritmusok/16. Haladó algoritmusok.tex b/16. Haladó algoritmusok/16. Haladó algoritmusok.tex new file mode 100644 index 0000000..7d4649a --- /dev/null +++ b/16. Haladó algoritmusok/16. Haladó algoritmusok.tex @@ -0,0 +1,139 @@ +\documentclass[margin=0px]{article} + +\usepackage{listings} +\usepackage[utf8]{inputenc} +\usepackage{graphicx} +\usepackage{float} +\usepackage[a4paper, margin=0.7in]{geometry} +\usepackage{subcaption} +\usepackage{amsthm} +\usepackage{amssymb} +\usepackage{amsmath} +\usepackage{fancyhdr} +\usepackage{setspace} + +\onehalfspacing + +\renewcommand{\figurename}{ábra} +\newenvironment{tetel}[1]{\paragraph{#1 \\}}{} +\newcommand{\R}{\mathbb{R}} + +\pagestyle{fancy} +\lhead{\it{PTI BSc Záróvizsga tételek}} +\rhead{16. Haladó algoritmusok} + +\title{\textbf{{\Large ELTE IK - Programtervező Informatikus BSc} \vspace{0.2cm} \\ {\huge Záróvizsga tételek}} \vspace{0.3cm} \\ 16. Haladó algoritmusok} +\author{} +\date{} + +\begin{document} +\maketitle + +\begin{tetel}{Haladó algoritmusok} + Elemi gráf algoritmusok: szélességi, mélységi bejárás és alkalmazásai. Minimális feszítőfák, általános algoritmus, Kruskal és Prim algoritmusai. Legrövidebb utak egy forrásból, sor alapú Bellman-Ford, Dijkstra, DAG legrövidebb út. Legrövidebb utak minden csúcspárra: Floyd-Warshall algoritmus. Gráf tranzitív lezártja. +\end{tetel} + +\section{Gráfalgoritmusok} +\subsection{Gráf ábrázolás} +\begin{description} + \item[Láncolt listás ábrázolás] \hfill \\ + A gráf csúcsait helyezzük el egy tömbben (vagy láncolt listában). Minden elemhez rendeljünk hozzá egy láncolt listát, melyben az adott csúcs szomszédjait (az esetleges élsúlyokkal) soroljuk fel. + \item[Mátrixos ábrázolás] \hfill \\ + Legyen a csúcsok elemszáma $n$. Ekkor egy $A^{n\times n}$ mátrixban jelöljük, hogy mely csúcsok vannak összekötve. Ekkor mind a sorokban, mind az oszlopokban a csúcsok szerepelnek, és az $a_{ij}$ cellában a $i$ csúcsból $j$ csúcsba vezető él súlya szerepel, ha nincs él a két csúcs között, akkor $-\infty$ (súlyozatlan esetben $1$ és $0$) + + Amennyiben a gráf irányítatlan nyilván $a_{ij} = a_{ji}$ +\end{description} +\subsection{Szélességi bejárás} +$G$ gráf (irányított/irányítatlan) $s$ startcsúcsából a távolság sorrendjében érjük el a csúcsokat. A legrövidebb utak feszítőfáját adja meg, így csak a távolság számít, a súly nem. + +A nyilvántartott csúcsokat egy sor adatszerkezetben tároljuk, az aktuális csúcs gyerekeit a sor-ba tesszük. A következő csúcs pedig a sor legelső eleme lesz. + +A csúcsok távolságát egy $d$, szüleiket egy $\pi$ tömbbe írjuk, és $\infty$ illetve $0$ értékekkel inicializáljuk. + +Az algoritmus: +\begin{enumerate} + \item Az $s$ startcsúcsot betesszük a sorba + \item A következő lépéseket addig ismételjük, míg a sor üres nem lesz + \item Kivesszük a sor legelső ($u$) elemét + \item Azokat a gyerekcsúcsokat, melyeknek a távolsága nem $\infty$ figyelmen kívül hagyjuk (ezeken már jártunk) + \item A többi gyerekre ($v$): beállítjuk a szülőjét ($\pi[v] = u$), és a távolságát ($d[v] = d[u]+1$). Majd berakjuk a sorba. +\end{enumerate} +\subsection{Minimális költségű utak keresése} +\begin{description} + \item[Dijkstra algoritmus] \hfill \\ + Egy $G$ irányított, pozitív élsúlyokkal rendelkező gráfban keres $s$ startcsúcsból minimális költségű utakat minden csúcshoz. + + Az algoritmus a szélességi bejárás módosított változata. Mivel itt egy hosszabb útnak lehet kisebb a költsége, mint egy rövidebbnek, egy már megtalált csúcsot nem szabad figyelmen kívül hagyni. Ezért minden csúcs rendelkezik három állapottal (nem elért, elért, kész). A $d$ és $\pi$ tömböket a szélességi bejáráshoz hasonlóan kezeljük. + + A még nem kész csúcsokat egy prioritásos sorba helyezzük, vagy minden esetben minimumkeresést alkalmazunk. + + Az algoritmus: + \begin{enumerate} + \item Az $s$ startcsúcs súlyát 0-ra állítjuk eltároljuk + \item A következő lépéseket addig ismételjük, míg a konténerünk üres nem lesz + \item Kivesszük a sor legjobb ($u$) elemét, és "kész"-re állítjuk + \item Ha egy gyerekcsúcs ($v$) nem kész, és a jelenleg hozzávezető út súlya kisebb, mint az eddigi, akkor: a szülőjét $u$-ra állítjuk ($\pi[v] = u$), és a súlyát frissítjük ($d[v] = d[u]+d(u,v)$). + \item A többi csúcsot kihagyjuk. + \end{enumerate} + + \item[Bellman-Ford algoritmus] \hfill \\ + Egy $G$ élsúlyozott (akár negatív) irányított gráf $s$ startcsúcsából keres minden élhez minimális költségű utakat, illetve felismeri, ha negatív költségű kör van a gráfban. A $d$ és $\pi$ tömböket az előzőekhez hasonlóan kezeljük. + + Az algoritmus: + \begin{enumerate} + \item A startcsúcs súlyát állítsuk be 0-ra. + \item $n-1$ iterációban menjünk végig az összes csúcson, és minden csúcsot ($u$) vessünk össze minden csúccsal ($v$). Ha olcsóbb utat találtunk akkor $v$-be felülírjuk a súlyát ($d[v] = d[u]+d(u,v)$), és a szülőjét ($\pi[v] = u$). + \item Ha az $n$-edik iterációban is történt módosítás, negatív kör van a gráfban + \end{enumerate} +\end{description} +\subsection{Minimális költség feszítőfa keresése} +A Prim algoritmus egy irányítatlan élsúlyozott (akár negatív) gráf $s$ startcsúcsából keres minimális költségű feszítőfát. A $d$ és $\pi$ tömböket az előzőekhez hasonlóan kezeljük. Az algoritmus egy prioritásos sorba helyezi a csúcsokat. + +Az algoritmus: +\begin{enumerate} + \item A startcsúcs súlyát állítsuk be 0-ra. + \item A csúcsokat behelyezzük a prioritásos sorba. + \item A következő lépéseket addig végezzük, míg a prioritásos sor ki nem ürül. + \item Kiveszünk egy csúcsot ($u$) a sorból. + \item Minden gyerekére ($v$), amely még a sorban és a nyilvántartott $v$-be vezető él súlya nagyobb, mint a most megtalált: A $v$ szülőjét $u$-ra változtatjuk, a nyilvántartott súlyt felülírjuk $d[v] = d(u,v)$. Majd felülírjuk a $v$ állapotát a prioritásos sorban. + \item Azokkal a gyerekekkel, melyek nincsenek a sorban, vagy a súlyukon nem tudunk javítani, nem változtatunk. +\end{enumerate} +\subsection{Mélységi bejárás} +$G$ irányított (nem feltétlenül összefüggő) gráf mélységi bejárásával egy mélységi fát (erdőt) kapunk. Az algoritmus a következő: +\begin{itemize} + \item Az élsúlyok nem játszanak szerepet + \item Nincs startcsúcs, a gráf minden csúcsára elindítjuk az algoritmust. (Természetesen ekkor, ha már olyan csúcsot választunk, amin már voltunk, az algoritmus nem indul el.) + \item A csúcsokat mohón választjuk, azaz minden csúcs gyerekei közül az elsőt választva haladunk előre, amíg csak lehet. (Olyan csúcsot találunk, amelynek nincs gyereke, vagy minden gyerekén jártunk már.) + \item Ha már nem lehet előre haladni visszalépünk. + \item Minden csúcshoz hozzárendelünk két értéket. Az egyik a mélységi sorszám, mely azt jelöli, hogy hanyadiknak értük el. A másik a befejezési szám, mely azt jelzi, hogy hanyadiknak léptünk vissza belőle. +\end{itemize} +A gráf éleit a mélységi bejárás közben osztályozhatjuk. (Inicializáláskor minden értéket 0-ra állítottunk) +\begin{itemize} + \item Faél: A következő csúcs mélységi száma 0 + \item Visszaél: A következő csúcs mélységi száma nagyobb, mint 0, és befejezési száma 0 (Tehát az aktuális út egy előző csúcsára kanyarodunk vissza) + \item Keresztél: A következő csúcs mélységi száma nagyobb, mint 0, és befejezési száma is nagyobb, mint 0, továbbá az aktuális csúcs mélységi száma nagyobb, mint a következő csúcs mélységi száma. (Ekkor egy az aktuális csúcsot megelőző csúcsból induló, már megtalált útba mutató éllel van dolgunk) + \item Előreél: A következő csúcs mélységi száma nagyobb, mint 0, és befejezési száma is nagyobb, mint 0, továbbá az aktuális csúcs mélységi száma kisebb, mint a következő csúcs mélységi száma. (Ekkor egy az aktuális csúcsból induló, már megtalált útba mutató éllel van dolgunk) +\end{itemize} +\subsection{DAG Topologikus rendezése} +\begin{description} + \item[Alapfogalmak] \hfill + \begin{itemize} + \item Topologikus rendezés: \\ + Egy $G(V,E)$ gráf topologikus rendezése a csúcsok olyan sorrendje, melyben $\forall (u\rightarrow v) \in E$ élre $u$ előbb van a sorrendben , mint $v$ + \item DAG - Directed Acyclic Graph: \\ + Irányított körmentes gráf. \\ + Legtöbbször munkafolyamatok irányítására illetve függőségek analizálására használják. + + Tulajdonságok: + \begin{itemize} + \item Ha $G$ gráfra a mélységi bejárás visszaélt talál (Azaz kört talált) $\Longrightarrow$ $G$ nem DAG + \item Ha $G$ nem DAG (van benne kör) $\Longrightarrow$ Bármely mélységi bejárás talál visszaélt + \item Ha $G$-nek van topologikus rendezések $\Longrightarrow$ $G$ DAG + \item Minden DAG topologikusan rendezhető. + \end{itemize} + \end{itemize} + \item[DAG topologikus rendezése] \hfill \\ + Egy $G$ gráf mélységi bejárása során tegyük verembe azokat a csúcsokat, melyekből visszaléptünk. Az algoritmus után a verem tartalmát kiírva megkapjuk a gráf egy topologikus rendezését. +\end{description} + +\end{document} \ No newline at end of file diff --git a/17. Operációs rendszerek/17. Operációs rendszerek.pdf b/17. Operációs rendszerek/17. Operációs rendszerek.pdf new file mode 100644 index 0000000..5e39467 Binary files /dev/null and b/17. Operációs rendszerek/17. Operációs rendszerek.pdf differ diff --git a/17. Operációs rendszerek/17. Operációs rendszerek.tex b/17. Operációs rendszerek/17. Operációs rendszerek.tex new file mode 100644 index 0000000..c80dc16 --- /dev/null +++ b/17. Operációs rendszerek/17. Operációs rendszerek.tex @@ -0,0 +1,668 @@ +\documentclass[margin=0px]{article} + +\usepackage{listings} +\usepackage[utf8]{inputenc} +\usepackage{graphicx} +\usepackage{float} +\usepackage[a4paper, margin=0.7in]{geometry} +\usepackage{amsthm} +\usepackage{amssymb} +\usepackage{t1enc} +\usepackage{fancyhdr} +\usepackage{setspace} + +\onehalfspacing + +\newenvironment{tetel}[1]{\paragraph{#1 \\}}{} + +\pagestyle{fancy} +\lhead{\it{PTI BSc Záróvizsga tételek}} +\rhead{17. Operációs rendszerek} + +\title{\textbf{{\Large ELTE IK - Programtervező Informatikus BSc} \vspace{0.2cm} \\ {\huge Záróvizsga tételek}} \vspace{0.3cm} \\ 17. Operációs rendszerek} +\author{} +\date{} + +\begin{document} +\maketitle + +\begin{tetel}{Operációs rendszerek} + Folyamatok megvalósítása, ütemező algoritmusaik. Párhuzamosság, kritikus szekciók, kölcsönös kizárás megvalósítása. Peterson algoritmus. Szemaforok, osztott memória, üzenetküldés. Be-és kimeneti eszközök ütemezési lehetőségei, holtpontok. Memóriakezelés, virtuális memóriakezelés fogalma. Lapozás és szegmentálás. Lapcserélési algoritmusok (pl: LRU). Háttértárak, redundancia, fájlrendszerek, alapvető típusaik és szolgáltatásaik, jellemzőik. +\end{tetel} + +\section{Operációs rendszer} +Olyan programrendszer, amely a számítógépes rendszerben a programok végrehajtását vezérli: így például ütemezi a programok végrehajtását, elosztja az erőforrásokat, biztosítja a felhasználó és a számítógépes rendszer közötti kommunikációt. Olyan program, ami egyszerű felhasználói felületet nyújt, eltakarva a számítógép(rendszer) eszközeit. \\ + +\section{Folyamatok megvalósítása, ütemező algoritmusaik} + +\subsection{Folyamatok megvalósítása} + +\textit{Program}: fájlrendszerben egy bájthalmaz. \\ +\textit{Folyamat}(processz): futó program a memóriában (kód + I/O adatok + állapot). \\ +Egyszerre hány folyamat működik? \\ +Valódi multitask esetén egymástól teljesen függetlenül mennek a folyamatok. Operációs rendszerek egy szekvenciális modellt követnek, ami álmultitasking. Itt egyidejűleg a memóriához csak egy folyamat fér hozzá, gyorsan váltogat a dolgok között (multiprogramozás). \\ +Az operációs rendszernek ahhoz, hogy ezeket a folyamatokat helyesen tudja kezelni, felügyelnie kell a folyamatokat. Az operációs rendszerünk így minden egyes folyamatot nyilvántart, és az operációs rendszer lelkének is nevezett ütemező (scheduler) segítségével szépen sorban minden egyes folyamatnak ad egy kis processzor- (CPU) időszeletet, amíg az adott folyamat dolgozik, azaz a processzorra kerülhet. +\textit{Rendszer modell}: 1 processzor + 1 rendszer memória + 1 I/O eszköz = 1 feladat-végrehajtás \\ +Interaktív (ablakos) rendszerekben több program, processz fut. +\begin{itemize} + \item Környezetváltásos rendszer: csak az előtérben lévő alkalmazás fut + \item Kooperatív rendszer: az aktuális processz bizonyos időközönként, vagy időkritikus műveletnél önként lemond a CPU-ról (Win 3.1) + \item Preemptív rendszer: az aktuális processztől a kernel bizonyos idő után elveszi a vezérlést, és a következő várakozó folyamatnak adja. + \item Real time rendszer: egy operációs rendszer nyújtson lehetőséget az időfaktor figyelembe vételéhez. A mai OR-ek kezdenek ilyen tulajdonságokkal is kiegészülni. +\end{itemize} + +\textit{Folyamatok létrehozása}: ma tipikusan preemptív rendszereket használunk. Létrehozás oka lehet: rendszer inicializálás, folyamatot eredményező rendszerhívás (másolat az eredetiről [fork], az eredeti cseréje [execve]), felhasználói kérés (parancs\&), nagy rendszerek kötegelt feladatai. \\ +A folyamatok futhatnak az előtérben, illetve a háttérben. Ez utóbbiakat hívjuk démonoknak.\\ +\textit{Folyamatok kapcsolata}: Szülő-gyermek kapcsolat, folyamatfa: egy folyamatnak egy szülője van, egy folyamatnak viszont lehet több gyereke is, vannak összetartozó folyamatcsoportok. \\ Reinkarnációs szerver: meghajtó programok, kiszolgálók elindítója, ha elhal az egyik, akkor azt újraszüli, reinkarnálja. \\ +\textit{Folyamatok befejezése}: Egy folyamat az elindulása után a megadott időkeretben (el)végzi a feladatát. A befejezés lehet önkéntes vagy önkéntelen. +\begin{itemize} + \item Önkéntes befejezések: Szabályos kilépés (exit, return stb.), Kilépés valamilyen hiba miatt, amit a program felfedez (szintén pl. return utasítással). + \item Önkéntelen befejezések: Illegális utasítás, végzetes hiba (0-val osztás, nem létező memória használat, stb), Külső segítséggel: Másik processz, netán mi ,,lőjük” ki az adott folyamatot. +\end{itemize} +\textit{Folyamatok állapota}: A folyamat önálló programegység, saját utasításszámlálóval, veremmel stb. Általában nem függetlenek a folyamatok, egyik-másik eredményétől függ a tevékenység. Egy folyamat három állapotban lehet: +\begin{itemize} + \item Futó + \item Futásra kész, ideiglenesen leállították, arra vár, hogy az ütemező CPU időt adjon a folyamatnak + \item Blokkolt, ha logikailag nem lehet folytatni a tevékenységet, mert pl. egy másik eredményére vár. (catFradi.txt|grepFradi|sort, grep és sort blokkolt az elején) +\end{itemize} +\begin{figure}[H] + \centering + \includegraphics[width=0.6\textwidth]{img/allapot.png} + \caption{Állapotátmenetek} +\end{figure} + +\textit{További állapotok}: alvó, megállított, zombi (ha egy gyermek folyamat befejeződik, de szülője nem hív wait(\&st) hívást, akkor a gyermek bent marad a processztáblában, init folyamat törli ezeket). \\ +\textit{\textbf{Folyamatok megvalósítása}}: A processzor csak végrehajtja az aktuális utasításokat. Egyszerre egy folyamat aktív. Folyamatokról nem tud a processzor. Ha lecseréljük az aktív folyamatot a következőre, akkor mindent meg kell őrizni, hogy visszatérhessünk a folytatáshoz. A ,,minden": utasításszámláló, regiszterek, lefoglalt memória állapot, nyitott fájl infók, stb. Ezeket az adatokat az úgynevezett folyamatleíró táblában tároljuk (processz tábla, processz vezérlő blokk). Van egy I/O megszakításvektor is. \\ +A folyamatokat úgy is osztályozhatjuk, hogy számításigényes vagy input/output-igényes (avagy beviteli/kiviteli, röviden B/K vagy I/O) folyamatról van-e szó. Könnyen belátható, hogy a számításigényes folyamatoknak az a legjobb, ha az ütemező általában hosszú időperiódusra adja meg nekik a processzort, míg az input/output-igényes folyamatoknak a rövidebb periódusidő a megfelelőbb. + +\subsection{Ütemező algoritmusok} + +\textit{Folyamatok váltása}: Kezdeményezheti időzítő, megszakítás, esemény, rendszerhívás kezdeményezés. Az ütemező elmenti az aktuális folyamat jellemzőket a folyamatleíró táblába. Betölti a következő folyamat állapotát, a processzor folytatja a munkát. Nem lehet menteni a gyorsítótárakat. Gyakori váltás többleterőforrást igényel. A folyamatváltási idő „jó” megadása nem egyértelmű. \\ +\textit{Folyamatleíró táblázat}(Process Control Block - PCB): A rendszer inicializálásakor létrejön; 1 elem, rendszerindító már bent van, mikor a rendszer elindul. Tömbszerű szerkezet (PID alapon), de egy-egy elem egy összetett processzus adatokat tartalmazó struktúra. Egy folyamat fontosabb adatai: Azonosítója (ID), neve (programnév); Tulajdonos, csoport azonosító; Memória, regiszter adatok stb. \\ +\textit{Szálak}: Önállóan működő programegységek (thread), egy folyamaton belüli különálló utasítássor. Általában egy folyamat = egy utasítássorozat = egy szál. Néha szükséges lehet, hogy egy folyamaton belül ,,több utasítássorozat" legyen. Gyakran ,,lightweight process"-nek nevezik a több utasítássorozatos folyamatot. Egy folyamaton belül több egymástól ,,független" végrehajtási sor lehet. Lehet egy folyamaton belül egy szál vagy egy folyamaton belül több szál. Ez utóbbi esetben, ha egy szál blokkolódik, a folyamat is blokkolva lesz. Van külön száltáblázat. \\ +Folyamatnak önálló címtartománya van, globális változói, megnyitott fájlleírói, gyermekfolyamatai, szignálkezelői, ébresztői stb., szálnak ezek nincsenek; viszont mindkettőnek vannak utasításszámlálói, regiszterei, van verme. \\ \\ + +Egyszerre csak 1 folyamat tud futni. Az ütemező hozza meg a döntést. Ütemezési algoritmus alapján dönti el, hogy melyik fusson. \\ +Folyamatváltás biztosan van: ha befejeződik egy folyamat, vagy ha egy folyamat blokkolt állapotba kerül (I/O vagy szemafor miatt). Általában van váltás: ha új folyamat jön létre, I/O megszakítás bekövetkezés (I/O megszakítás után jellemzően egy blokkolt folyamat, ami erre várt, folytathatja futását), időzítő megszakítás (nem megszakítható ütemezés, megszakítható ütemezés). \\ +Ütemezések csoportosítása: +\begin{itemize} + \item Minden rendszerre jellemző a pártatlanság, hogy mindenki hozzáférhet a CPU-hoz, ugyanazok az elvek érvényesek mindenkire, és ,,azonos” terhelést kapnak. + \item Kötegelt rendszerek: Áteresztőképesség, áthaladási idő, CPU kihasználtság + \item Interaktív rendszerek: Válaszidő, megfelelés a felhasználói igényeknek + \item Valós idejű rendszerek: Határidők betartása, adatvesztés, minőségromlás + elkerülése +\end{itemize} +\textbf{Ütemezés kötegelt rendszerekben}: +\begin{itemize} + \item Sorrendi ütemezés, nem megszakítható + \begin{itemize} + \item First Come First Served - (FCFS) + \item Egy folyamat addig fut, amíg nem végez, vagy nem blokkolódik. + \item Ha blokkolódik, a sor végére kerül. + \item Pártatlan, egyszerű, láncolt listában tartjuk a folyamatokat. + \item Hátránya: I/O igényes folyamatok nagyon lassan végeznek. + \end{itemize} + \item Legrövidebb feladat először, nem megszakítható ez se (shortest job first -- SJB) + \begin{itemize} + \item Kell előre ismerni a futási időket + \item Akkor optimális, ha kezdetben mindenki elérhető + \end{itemize} + \item Legrövidebb maradék futási idejű következzen + \begin{itemize} + \item Megszakítható, minden új belépéskor vizsgálat. + \end{itemize} + \item Háromszintű ütemezés + \begin{itemize} + \item Bebocsátó ütemező: A feladatokat válogatva engedi be a memóriába. + \item Lemez ütemező: Ha a bebocsátó sok folyamatot enged be és elfogy a memória, akkor lemezre kell írni valamennyit, meg vissza. Ez ritkán fut. + \item CPU ütemező: A korábban említett algoritmusok közül választhatunk. + \end{itemize} +\end{itemize} +\textbf{Ütemezés interaktív rendszerekben}: +\begin{itemize} + \item Körben járó ütemezés -- Round Robin + \begin{itemize} + \item Mindenkinek időszelet, aminek végén, vagy blokkolás esetén jön a következő folyamat + \item Időszelet végén a körkörös listában következő lesz az aktuális folyamat + \item Pártatlan, egyszerű + \item Egy listában tárolhatjuk a folyamatokat (jellemzőit), és ezen megyünk körbe-körbe. + \item Időszelet mérete lehet probléma, mert a processz átkapcsolás időigényes. Ha kicsi az idő, akkor sok CPU megy el a kapcsolgatásra, ha pedig túl nagy, akkor interaktív felhasználóknak lassúnak tűnhet pl a billentyűkezelés. + \end{itemize} + \item Prioritásos ütemezés + \begin{itemize} + \item Fontosság, prioritás bevezetése. Unix: 0-49 nem megszakítható (kernel) prioritás, 50-127 user prioritás + \item Legmagasabb prioritású futhat. Dinamikus prioritás módosítás, különben éhenhalás + \item Prioritási osztályok használata. Egy osztályon belül Round Robin. Ki kell igazítani a folyamatok prioritását, különben az alacsonyak nagyon ritkán jutnak CPU-hoz. Tipikusan minden 100 időszeletnél a prioritásokat újraértékeli és ilyenkor jellemzően a magas prioritások alacsonyabbra kerülnek, majd ezen a soron megy RR. A végén újra felállnak az eredeti osztályok. + \end{itemize} + \item Többszörös sorok + \begin{itemize} + \item Szintén prioritásos és RR + \item Legmagasabb szinten minden folyamat 1 időszeletet kap + \item Következő 2-t, majd 4-et, 8, 16,32,64-et. + \item Ha elhasználta a legmagasabb szintű folyamat az idejét egy szinttel lejjebb kerül. + \end{itemize} + \item Legrövidebb folyamat előbb + \begin{itemize} + \item Bár nem tudjuk a hátralévő időt, de becsüljük meg az előzőekből. + \item Öregedés, súlyozott átlag az időszeletre: T0, T0/2+T1/2, T0/4+T1/4+T2/2, T0/8+T1/8+T2/4+T3/2 + \end{itemize} + \item Garantált ütemezés + \begin{itemize} + \item Minden aktív folyamat arányos CPU időt kap. + \item Nyilván kell tartani, hogy egy folyamat már mennyi időt kapott, ha valaki arányosan kevesebb időt kapott, az kerül előbbre. + \end{itemize} + \item Sorsjáték ütemezés + \begin{itemize} + \item Mint az előző, csak a folyamatok között ,,sorsjegyeket" osztunk szét, az kapja a vezérlést, akinél a kihúzott jegy van + \item Arányos CPU időt könnyű biztosítani, hasznos pl. video szervereknél + \end{itemize} + \item Arányos ütemezés + \begin{itemize} + \item Vegyük figyelembe a felhasználókat is. Olyan, mint a garantált, csak a felhasználókra vonatkoztatva. + \end{itemize} +\end{itemize} +\textbf{Ütemezés valós idejű rendszerekben} \\ +A valós idejű rendszerben az idő kulcsszereplő. Garantálni kell adott határidőre a tevékenység, válasz megadását. +\begin{itemize} + \item Hard Real Time (szigorú), abszolút, nem módosíthatóhatáridők. + \item Soft Real Time (toleráns), léteznek a határidők, de ezek kis mértékű elmulasztása tolerálható. +\end{itemize} +A programokat több kisebb folyamatra bontják. Külső esemény észlelésekor, adott határidőre válasz +kell. Ütemezhető: ha egységnyi időre eső n esemény CPU válaszidő összege <=1. \\ +Gyakori a gyermek folyamatok jelenléte a rendszerben. A szülőnek nem biztos, hogy minden +gyermekével azonos prioritásra van szüksége. Tipikusan a kernel \textit{prioritásos ütemezést} +használ (+RR): +\begin{itemize} + \item Biztosít egy rendszerhívást, amivel a szülő a gyermek prioritását adhatja meg + \item Kernel ütemez -- felhasználói folyamat szabja meg az elvet, prioritást. +\end{itemize} + +\textbf{Szálütemezés}: +\begin{itemize} + \item Felhasználói szintű szálak + \begin{itemize} + \item Kernel nem tud róluk, a folyamat kap időszeletet, ezen belül a szálütemező dönt ki fusson + \item Gyors váltás a szálak között + \item Alkalmazásfüggő szálütemezés lehetséges + \end{itemize} + \item Kernel szintű szálak + \begin{itemize} + \item Kernel ismeri a szálakat, kernel dönt melyik folyamat melyik szála következzen + \item Lassú váltás, két szál váltása között teljes környezetátkapcsolás kell + \item Ezt figyelembe is veszik. + \end{itemize} +\end{itemize} + +\section{Párhuzamosság, kritikus szekciók, kölcsönös kizárás megvalósítása} + +\subsection{Párhuzamosság és megvalósítása} + +Ütemező a folyamatok gyors váltogatásával ,,teremt" párhuzamos végrehajtás érzetet. \\ +Többprocesszoros rendszerekben több processzor van egy gépben, nagyobb a teljesítmény, de a megbízhatóságot általában nem növeli. \\ +Klaszterek: megbízhatóság növelése elsősorban a cél. + +\subsection{Kritikus szekciók} + +Azokat az utasításokat, azt a programrészt, amelyben a programunk a közös adatokat használja, kritikus területnek, kritikus szekciónak vagy kritikus blokknak nevezzük. \\ +Kulcskérdés: a közös erőforrások használata, amikor két folyamat ugyanazt a memóriát használja. Kritikus programterület, szekció, az a rész, mikor a közös erőforrást (memóriát) használjuk. \\ +Versenyhelyzet: két vagy több folyamat közös memóriát ír vagy olvas, a végeredmény a futási időpillanattól függ. Nehezen felderíthető hibát okoz. \\ +Megoldás: Módszer, ami biztosítja, hogy a közös adatokat egyszerre csak egy folyamat tudja használni. + +\subsection{Kölcsönös kizárás és megvalósítása} + +Kölcsönös kizárásnak nevezzük azt a módszert, ami biztosítja, hogy ha egy folyamat használ valamilyen megosztott, közös adatot, akkor más folyamatok ebben az időben ne tudják azt elérni. \\ +A jó kölcsönös kizárás az alábbi feltételeknek felel meg: +\begin{itemize} + \item Nincs két folyamat egyszerre a kritikus szekciójában. + \item Nincs sebesség, CPU paraméter függőség. + \item Egyetlen kritikus szekción kívül levő folyamat sem blokkolhat másik folyamatot. + \item Egy folyamat sem vár örökké, hogy a kritikus szekcióba tudjon belépni. +\end{itemize} + +\begin{figure}[H] + \centering + \includegraphics[width=0.9\textwidth]{img/mutex.png} + \caption{A megkívánt kölcsönös kizárás viselkedése} +\end{figure} + +\subsubsection{Megvalósítások} + +\begin{itemize} + \item Megszakítások tiltása (összes): Belépéskor az összes megszakítás tiltása, Kilépéskor azok engedélyezése. Ez nem igazán jó, mivel a felhasználói folyamatok kezében lenne a megszakítások tiltása, persze a kernel használja. + \item Osztott, ún. zárolás változó használata: 0 (senki) és 1 (valaki) kritikus szekcióban van. Két folyamat is kritikus szekcióba tud kerülni! Egyik folyamat belép a kritikus szekcióba, de éppen az 1-re állítás előtt a másik folyamat kerül ütemezésre. + \item Szigorú váltogatás: Több folyamatra is általánosítható. A kölcsönös kizárás feltételeit teljesíti a 3. kivételével, ugyanis ha pl 1 folyamat a lassú, nem kritikus szekcióban van, és a 0 folyamat gyorsan belép a kritikus szekcióba, majd befejezi a nem kritikus szekciót is, akkor ez a folyamat blokkolódik mert a kovetkezo=1 lesz!(Saját magát blokkolja!) + \begin{figure}[H] + \centering + \includegraphics[width=0.9\textwidth]{img/szigoru.png} + \caption{Szigorú váltogatás} + \end{figure} + \item G. L. Peterson javította a szigorú váltogatást. A kritikus szekció előtt minden folyamat meghívja a belépés, majd utána kilépés függvényt. + \begin{figure}[H] + \centering + \includegraphics[width=0.6\textwidth]{img/peterson.png} + \includegraphics[width=0.3\textwidth]{img/petersonhiba.png} + \caption{Peterson javítása és a benne rejlő hiba} + \end{figure} + Ez a javítás viszont nagy hibát okozhat. Tegyük fel proc=0. A jelölt ütemezés váltásnál a proc=1 belépése jön. Mivel akarja[0] értéke 0, ezért az 1-es process belép a kritikus szakaszba! Ekkor újra váltson az ütemező, akarja[1]=1, a következő értéke szintén 1, így a következo==proc hamis, azaz a 0. proc is belép a kritikus szakaszba! + \item Tevékeny várakozás gépi kódban: TSL utasítás, Test and Set Lock. Ez atomi művelet, vagyis megszakíthatatlan. + \item Tevékeny várakozás: A korábbi Peterson megoldás is, a TSL használata is jó, csak ciklusban várakozunk. A korábbi megoldásokat, tevékeny várakozással (aktív várakozás) megoldottnak hívjuk, mert a CPU-t ,,üres" ciklusban járatjuk a várakozás során.De ez a CPU időt pazarolja. Helyette jobb lenne az, ha a kritikus szekcióba lépéskor blokkolna a folyamat, ha nem szabad belépnie. Az aktív várakozás nem igazán hatékony. Megoldás: blokkoljuk(alvás) várakozás helyett a folyamatot, majd ha megengedett ébresszük fel. Különböző paraméter megadással is implementálhatók. Tipikus probléma: Gyártó-Fogyasztó probléma vagy másképp korlátos tároló probléma. PL: Pék-pékség-Vásárló háromszög: + \begin{itemize} + \item A pék süti a kenyeret, amíg a pékség polcain van hely. + \item Vásárló tud venni, ha a pékség polcain van kenyér. + \item Ha tele van kenyérrel a pékség, akkor ,,a pék elmegy pihenni". + \item Ha üres a pékség, akkor a vásárló várakozik a kenyérre. + \end{itemize} + \begin{figure}[H] + \centering + \includegraphics[width=0.9\textwidth]{img/pekvasarlo.png} + \caption{Gyártó-fogyasztó probléma egy megvalósítása} + \end{figure} + Ennél a megvalósításnál probléma lehet, hogy A ,,hely" változó elérése nem korlátozott, így ez okozhat versenyhelyzetet. + \begin{itemize} + \item Vásárló látja, hogy a hely 0 és ekkor az ütemező átadja a vezérlést a péknek, aki süt egy kenyeret. Majd látja, hogy a hely 1, ébresztőt küld a vásárlónak. Ez elveszik, mert még a vásárló nem alszik. + \item Vásárló visszakapja az ütemezést, a helyet korábban beolvasta, az 0, megy aludni. + \item A pék az első után megsüti a maradék N-1 kenyeret és ő is aludni megy + \end{itemize} + Lehet ébresztő bittel javítani, de több folyamatnál a probléma nem változik. +\end{itemize} + +\section{Szemaforok, osztott memória, üzenetküldés} + +\subsection{Szemaforok} + +E.W. Dijkstra(1965) javasolta ezen új változótípus bevezetését. +\begin{itemize} + \item Ez valójában egy egész változó. + \item A szemafor tilosat mutat, ha értéke 0. Ekkor a folyamat elalszik, megáll a tilos jelzés előtt. + \item Ha a szemafor >0, szabad a pálya, beléphetünk a kritikus szakaszra. Két művelet tartozik hozzá: ha beléptünk, csökkentjük szemafor értékét (down); ha kilépünk, növeljük a szemafor értékét (up). Ezeket Dijkstra P és V műveletnek nevezte. +\end{itemize} +Elemi művelet: a szemafor változó ellenőrzése, módosítása, esetleges elalvás oszthatatlan művelet, nem lehet megszakítani. Ez garantálja, hogy ne alakuljon ki versenyhelyzet. \\ +Ha a szemafor tipikus vasutas helyzetet jelöl, azaz 1 vonat mehet át csak a jelzőn, a szemafor értéke ekkor 0 vagy 1 lehet. Ez a \textit{bináris szemafor}, vagy más néven MUTEX (Mutual Exclusion), és kölcsönös kizárásra használjuk. \\ +Rendszerhívással, felhasználói szinten nem biztosítható a műveletek atomiságának megvalósítása. Művelet elején például letiltunk minden megszakítást. Ha több CPU van, akkor az ilyen szemafort védeni tudjuk a TSL utasítással. Viszont ezek a szemafor műveletek kernel szintű, rendszerhívás műveletek. A fejlesztői környezetek biztosítják. +\begin{figure}[H] + \centering + \includegraphics[width=0.45\textwidth]{img/gyarto_szemafor.png} + \includegraphics[width=0.45\textwidth]{img/fogyaszto_szemafor.png} + \caption{Gyártó-fogyasztó probléma megoldása szemaforokkal} +\end{figure} +\textit{Szabad}: kenyér polcot (boltot) védi, hogy egy időben csak egy folyamat tudja használni (vagy a pék, vagy a vásárló): Kölcsönös kizárás, Elemi műveletek (up, down). \\ +\textit{Tele, üres szemafor}: szinkronizációs szemaforok, a gyártó álljon meg ha a tároló tele van, illetve a fogyasztó is várjon ha a tároló üres. \\ \\ +Szemafornál két utasítás felcserélése is gondot okozhat. \\ +\textit{Monitor}: magasabb szintű, nyelvű konstrukció. Eljárások, adatszerkezetek +lehetnek benne. Egy időben csak egy folyamat lehet aktív a monitoron belül. + +\subsection{Osztott memória} + +Elosztott közös memória: Hálózatban futó folyamatok közti memóriamegosztás. \\ +Lehetőségünk van egy programon belüli különböző folyamatok, szálak által használt memóriaterületek közössé tételére, vagyis használhatjuk ugyanazt a memóriarészt, ,,időosztásos" üzemmódban. Különböző, egymással valamilyen módon ,,összekapcsolt" programrészekhez, folyamokhoz, szálakhoz ugyanazt a memóriaterület kapcsoljuk. + +\subsection{Üzenetküldés} + +A folyamatok jellemzően két primitívet használnak: \textit{Send(célfolyamat, üzenet)}, \textit{Receive(forrás, üzenet)}. Ezek rendszerhívások, nem nyelvi konstrukciók. \\ +Ha küldő-fogadó nem azonos gépen van, szükséges ún. nyugtázó üzenet. Így ha küldő nem kapja meg a nyugtát, ismét elküldi az üzenetet. Ha a nyugta veszik el, a küldő újra küld. Ismételt üzenetek megkülönböztetése sorszám segítségével történik. \\ +\textit{Összegzés}: Ideiglenes tároló helyek (levelesláda) létrehozása mindkét helyen. El lehet hagyni, ekkor ha send előtt van receive, a küldő blokkolódik, illetve fordítva. Ezt hívják randevú stratégiának. Például a Minix 3 is randevút használ, rögzített méretű üzenetekkel. \\ +Adatcső kommunikáció hasonló, csak az adatcsőben nincsenek üzenethatárok, ott csak bájtsorozat van. Az üzenetküldés a párhuzamos rendszerek általános technikája. Pl. MPI \\ +Klasszikus IPC (inter-process communication) problémák: +\begin{itemize} + \item Étkező filozófusok esete: körben felváltva 5 villa, tányér. 2 villa kell a spagetti + evéshez. A tányér melletti villákra pályáznak. Esznek-gondolkoznak. A legegyszerűbb megoldás (végtelen ciklusban gondolkodik, felveszi a két villáját egymás után, eszik, leteszi a villákat) pár hibát rejt magában, hogy pl. holtpont lehet, ha egyszerre megszerzik a bal villát és mind várnak a jobbra. Illetve ha leteszi a bal villát és újra próbálkozik, még az + se az igazi, hiszen folyamatosan felveszik a bal villát, majd leteszik. (Éhezés) + \begin{figure}[H] + \centering + \includegraphics[width=0.3\textwidth]{img/filo.png} + \caption{Étkező filozófusok, javított megoldás: 5 villa szemafor van, és egy maximum. Korlátozott erőforrás megszerzésre példa} + \end{figure} + \item Író-olvasó probléma: Adatbázist egyszerre többen olvashatják, de csak 1 folyamat írhatja. + \begin{figure}[H] + \centering + \includegraphics[width=0.3\textwidth]{img/iro.png} + \includegraphics[width=0.3\textwidth]{img/olvaso.png} + \caption{Író-olvasó probléma megvalósítása} + \end{figure} +\end{itemize} + +\section{Be- és kimeneti eszközök ütemezési lehetőségei, holtpontok} + +\subsection{Be- és kimeneti eszközök ütemezési lehetőségei} + +Input-Output eszközök: +\begin{itemize} + \item \textit{Blokkos eszközök}. Adott méretű blokkban tároljuk az információt. Blokkméret 512 byte - 32768 byte között. Egymástól függetlenül írhatók vagy olvashatók. Blokkonként címezhetőek. Ilyen eszköz: HDD, szalagos egység + \item \textbf{Karakteres eszközök}. Nem címezhető, csak jönnek-mennek sorban a + ,,karakterek" (bájtok) + \item \textbf{Időzítő}: kivétel, nem blokkos és nem + karakteres +\end{itemize} +\textit{Megszakítások}: Általában az eszközöknek van állapotbitjük, jelezve, hogy az adat készen van. \\ +Megszakítás használat (IRQ): +\begin{enumerate} + \item CPU tevékenység megszakítása + \item a kért sorszámú kiszolgáló végrehajtása + \item a kívánt adat beolvasása, a szorosan hozzátartozó tevékenység elvégzése + \item visszatérés a megszakítás előtti állapothoz. +\end{enumerate} +\textit{Közvetlen memória elérés}(DMA): Direct Memory Access, tartalmaz memória cím regisztert, átvitel irány jelzésre, mennyiségre regisztert. Ezeket szabályos in, out portokon lehet elérni. \\ +Működés lépései: +\begin{enumerate} + \item CPU beállítja a DMA vezérlőt. (Regisztereket.) + \item A DMA a lemezvezérlőt kéri a megadott műveletre. + \item Miután a lemezvezérlő beolvasta a pufferébe, a rendszersínen keresztül a memóriába(ból) írja, olvassa az adatot. + \item Lemezvezérlő nyugtázza, hogy kész a kérés teljesítése. + \item DMA megszakítással jelzi, befejezte a műveletet. +\end{enumerate} + +\subsection{Holtpontok (deadlock)} + +Két vagy több folyamat egy erőforrás megszerzése során olyan helyzetbe kerül, hogy egymást blokkolják a további végrehajtásban. Pontos definíció: Folyamatokból álló halmaz holtpontban van, ha minden folyamat olyan eseményre vár, amit csak a halmaz egy másik folyamata okozhat. Nem csak az I/O eszközökhöz kötődik, pl párhuzamos rendszerek, adatbázisok, stb. \\ +Coffman E.G. szerint 4 feltétel szükséges a holtpont kialakulásához: +\begin{enumerate} + \item \textit{Kölcsönös kizárás feltétel.} Minden erőforrás hozzá van rendelve 1 folyamathoz vagy szabad. + \item \textit{Birtoklás és várakozás feltétel.} Korábban kapott erőforrást birtokló folyamat kérhet újabbat. + \item \textit{Megszakíthatatlanság feltétel.} Nem lehet egy folyamattól elvenni az erőforrást, csak a folyamat engedheti el. + \item \textit{Ciklikus várakozás feltétel.} Két vagy több folyamatlánc kialakulása, amiben minden folyamat olyan erőforrásra vár, amit egy másik tart fogva. +\end{enumerate} +Irányított gráffal lehet modellezni a folyamatokat és erőforrásokat. Ha van kör, akkor az holtpontot jelent. \\ \\ +Stratégiék holtpont esetén: +\begin{enumerate} + \item A probléma figyelmen kívül hagyása. + \begin{itemize} + \item Nem törődünk vele, nagy valószínűséggel Ő sem talál meg bennünket. + \item Ezt a módszert gyakran strucc algoritmus néven is ismerjük. + \item Vizsgálatok szerint a holtpont probléma és az egyéb (fordító, op.rendszer, hw, sw hiba) összeomlások aránya 1:250. + \item A Unix, Windows világ is ezt a „módszert” használja. De túl nagy az ár a várható haszonért cserébe. + \end{itemize} + \item Felismerés és helyreállítás. + \begin{itemize} + \item Engedjük a holtpontot megjelenni (kör), ezt észrevesszük és cselekszünk. + \item Folyamatosan figyeljük az erőforrás igényeket, elengedéseket. + \item Kezeljük az erőforrás gráfot folyamatosan. Ha kör keletkezik, akkor egy körbeli folyamatot megszüntetünk. + \item Másik módszer, nem foglalkozunk az erőforrás gráffal, ha x (fél óra?) ideje blokkolt egy folyamat, egyszerűen megszüntetjük. Ez nagygépes rendszereknél ismert módszer. + \end{itemize} + \item Megelőzés. + \begin{itemize} + \item A 4 szükséges feltétel egyikének meghiúsítása. + \item A Coffman féle 4 feltétel valamelyikére mindig él egy megszorítás. + \begin{itemize} + \item Kölcsönös kizárás. Ha egyetlen erőforrás soha nincs kizárólag 1 folyamathoz rendelve, akkor nincs holtpont se. De ez nehézkes, míg pl. nyomtató használatnál a + nyomtató démon megoldja a problémát, de ugyanitt a nyomtató puffer egy lemezterület, itt már kialakulhat holtpont. + \item Ha nem lehet olyan helyzet, hogy erőforrásokat birtokló folyamat további erőforrásra várjon, akkor szintén nincs holtpont. Ezt kétféle módon érhetjük el: Előre kell tudni egy folyamat összes erőforrásigényét vagy ha erőforrást akar egy folyamat, először engedje el az összes birtokoltat. + \item A Coffman féle harmadik feltétel a megszakíthatatlanság. Ennek elkerülése eléggé + nehéz. Pl nyomtatás közben nem szerencsés a nyomtatót másnak adni. + \item A negyedik feltétel, a ciklikus várakozás már könnyebben megszüntethető. Egyszerű mód: Minden folyamat egyszerre csak 1 erőforrást birtokolhat. Másik módszer: Sorszámozzuk az erőforrásokat, és a folyamatok csak ezen sorrendben kérhetik az erőforrásokat. Ez jó elkerülési mód, csak megfelelő sorrend nincs. + \end{itemize} + \end{itemize} + \item Dinamikus elkerülés. + \begin{itemize} + \item Erőforrások foglalása csak ,,óvatosan". + \item Bankár algoritmus (Dijkstra, 1965) Mint a kisvárosi bankár hitelezési gyakorlata. A bankár algoritmus minden kérés megjelenésekor azt nézi, hogy a kérés teljesítése biztonságos + állapothoz vezet-e. Ha igen, jóváhagyja, ha nem, a kérést elhalasztja. Eredetileg 1 erőforrásra tervezett. \\ + A korábbi megelőzés is, meg ez az elkerülés is olyan információt kér (az erőforrás pontos igényeket, a folyamatok számát előre), ami nehezen megadható. (Folyamatok dinamikusan jönnek létre, erőforrások dinamikusan módosulnak.) Ezért a gyakorlatban kevesen alkalmazzák. + \item Biztonságos állapotok, olyan helyzetek, melyekből létezik olyan kezdődő állapotsorozat, melynek eredményeként mindegyik folyamat megkapja a kívánt erőforrásokat és befejeződik. + \end{itemize} +\end{enumerate} + +\section{Memóriakezelés, virtuális memória fogalma} + +\textit{Monoprogramozás}: A legegyszerűbb memóriakezelési módszer, időben csak egyetlen programot futtatunk. \\ +\textit{Multiprogramozás}: multiprogramozás rögzített partíciókkal: Ekkor a rendelkezésre álló memóriát felosztják több, általában nem egyforma hosszúságú részre. Működéséhez minden partíciónak szüksége van egy úgynevezett várakozási sorra. Ha beérkezik egy igény, az operációs rendszer berakja annak a legkisebb méretű, partíciónak nevezett rész várakozási sorába, ahová még befér. Ilyenkor elvész a partíciónak az a része – nem használható –, amit az éppen futó processz nem használ. Ha az adott szeletben befejeződik a munka, a legrégebben várakozó megkapja a területet, és elkezd működni. + +\subsection{Memóriakezelés} + +A memóriakezelő az operációs rendszer része, gyakran a kernelben. Feladata: a memória nyilvántartása, melyek szabadok, foglaltak; memóriát foglaljon folyamatok számára; memóriát felszabadítson; csere vezérlése a RAM és a (Merev)Lemez között. \\ +Kétféle algoritmus csoport: +\begin{itemize} + \item Szükséges a folyamatok mozgatása, cseréje a memória és a lemez között. (swap) + \item Nincs erre szükség, ha elegendő memória van. +\end{itemize} + +\textit{Multiprogramozás rögzített memóriaszeletekkel}: Osszuk fel a memóriát n (nem egyenlő) szeletre. (Fix szeletek) Pl. rendszerindításnál ez megtehető. Egy közös várakozási sor van, minden szeletre külön-külön várakozási sor. Kötegelt rendszerek tipikus megoldása. \\ +\textit{Relokáció}: Nem tudjuk hova kerül egy folyamat, így a memória hivatkozások nem fordíthatók fix értékekre. \\ +\textit{Védelem}: Nem kívánatos, ha egy program a másik memóriáját ,,éri el". \\ +Másik megoldás: Bázis+határregiszter használata, ezeket a programok nem módosíthatják, de minden címhivatkozásnál ellenőrzés: lassú. \\ +\textit{Multiprogramozás memóriacsere használattal}: A korábbi kötegelt rendszerek tipikus megoldása a rögzített memória szeletek használata (IBM OS/MFT). Időosztásos, grafikus felületek esetén ez nem az igazi. Itt a teljes folyamatot mozgatjuk a memória-lemez között. Nincs rögzített memória partíció, mindegyik dinamikusan változik, ahogy az op. rendszer oda-vissza rakosgatja a folyamatokat. Dinamikus, jobb memória kihasználtságú lesz a rendszer, de a sok csere lyukakat hoz létre, ezért memória tömörítést kell végezni. (Sok esetben ez az időveszteség nem megengedhető.) \\ +\textit{Dinamikus memóriafoglalás}: Általában nem ismert, hogy egy programnak mennyi dinamikus adatra, veremterületre van szüksége. A program ,,kód" része fix szeletet kap, míg az adat és verem része változót. Ezek tudnak nőni (csökkenni). Ha elfogy a memória, akkor a folyamat leáll, vár a +folytatásra, vagy kikerül a lemezre, hogy a többi még futó folyamat memóriához jusson. Ha van a memóriában már várakozó folyamat, az is cserére kerülhet. \\ +A ,,dinamikus" memória nyilvántartása: +\begin{itemize} + \item Allokációs egység definiálása. Ennek mérete kérdés. Ha kicsi, akkor kevésbé lyukasodik a memória, viszont nagy a nyilvántartási ,,erőforrás (memória) igény". Ha nagy az egység, akkor túl sok lesz az egységen belüli maradékokból adódó memóriaveszteség. + \item A nyilvántartás megvalósítása: Bittérkép használattal vagy Láncolt lista használattal. Ha egy folyamat befejeződik, akkor szükség lehet az egymás melletti memória lyukak egyesítésére. Külön lista a lyukak és folyamatok listája. +\end{itemize} +\textit{Memóriafoglalási stratégiák}: Új vagy swap partícióról behozott folyamat számára, több memória elhelyezési algoritmus ismert (hasonlóak a lemezhez): +\begin{itemize} + \item First Fit (első helyre, ahova befér, leggyorsabb, legegyszerűbb) + \item Next Fit (nem az elejéről, hanem az előző befejezési pontjából indul a keresés, kevésbé hatékony, mint a first fit) + \item Best Fit (lassú, sok kis lyukat produkál) + \item Worst Fit (nem lesz sok kis lyuk, de nem hatékony) + \item Quick Fit (méretek szerinti lyuklista, a lyukak összevonása költséges) +\end{itemize} + +\subsection{Virtuális memória fogalma} + +\textit{Multiprogramozás virtuális memóriahasználattal}: Egy program használhat több memóriát, +mint a rendelkezésre álló fizikai méret. Az operációs rendszer csak a ,,szükséges részt" tartja a fizikai memóriában. Egy program a ,,virtuálismemória-térben" tartózkodik. Az elv akár a monoprogramozás környezetben is használható. \\ +\textit{Memory Management Unit (MMU)}: A virtuális címtér ,,lapokra" van osztva. (Ezt laptáblának +nevezzük). Van jelenlét/hiány bit. Virtuális-fizikai lapokat összerendeljük. Ha az MMU látja, hogy egy lap nincs a memóriában, laphibát okoz, op.rendszer kitesz egy lapkeretet, majd behozza a szükséges lapot. + +\section{Lapozás és szegmentálás} + +\subsection{Lapozás} + +\textit{Lapozástervezési szempontok}: +\begin{itemize} + \item Munkahalmaz modell + \begin{itemize} + \item A szükséges lapok betöltése. (Induláskor-előlapozás) A folyamat azon lapjainak fizikai memóriában tartása, melyeket használ. Ez az idővel változik. + \item Nyilván kell tartani a lapokat. Ha egy lapra az utolsó N időegységben nem hivatkoznak, laphiba esetén kidobjuk. + \item Óra algoritmus javítása: Vizsgáljuk meg, hogy a lap eleme a munkahalmaznak? (WSClock algoritmus) + \end{itemize} + \item Lokális, globális helyfoglalás + \begin{itemize} + \item Egy laphibánál ha az összes folyamatot (globális), vagy csak a folyamathoz tartozó (lokális) lapokat vizsgáljuk. + \item Globális algoritmus esetén minden folyamatot elláthatunk méretéhez megfelelő lappal, amit aztán dinamikusan változtatunk. + \item Page Fault Frequency (PFF) algoritmus, laphiba/másodperc arány, ha sok a laphiba, növeljük a folyamat memóriában lévő lapjainak a számát. Ha sok a folyamat, akár teljes folyamatot lemezre vihetünk.(teherelosztás) + \end{itemize} + \item Helyes lapméret meghatározása. + \begin{itemize} + \item Kicsi lapméret: A ,,lapveszteség" kicsi, viszont nagy laptábla kell a nyilvántartáshoz. + \item Nagy lapméret: Fordítva, ,,lapveszteség" nagy, kicsi laptábla. + \item Jellemzően: n x 512 bájt a lapméret, XP, Linuxok 4KB a lapméret. 8KB is használt (szerverek). + \end{itemize} + \item Közös memória + \begin{itemize} + \item Foglalhatunk memóriaterületet, amit több folyamat használhat. + \item Elosztott közös memória: Hálózatban futó folyamatok közti memóriamegosztás. + \end{itemize} +\end{itemize} + +\subsection{Szegmentálás} + +Virtuális memória: egy dimenziós címtér, 0-tól a maximum címig (4,8,16 GB, ...). \\ +Több programnak van dinamikus területe, melyek növekedhetnek, bizonytalan mérettel. Hozzunk létre egymástól független címtereket, ezeket szegmensnek nevezzük. \\ +Ebben a világban egy cím 2 részből áll: szegmens szám, és ezen belüli cím. (eltolás) \\ +Szegmentálás lehetővé teszi osztott könyvtárak ,,egyszerű" megvalósítását. Logikailag szét lehet szedni a programot, adat szegmens, kód szegmens stb. Védelmi szintet is megadhatunk egy szegmensre. Lapok fix méretűek, a szegmensek nem. Szegmens töredezettség megjelenése. Ez töredezettség-összevonással javítható. + +\section{Lapcserélési algoritmusok} + +Ha nincs egy virtuális című lap a memóriában, akkor egy lapot ki kell dobni, berakni ezt az új lapot. A processzor gyorsító tár (cache) memória használatnál, vagy a böngésző helyi gyorsítótáránál is hasonló a helyzet. +Optimális lapcserélés: Címkézzünk meg minden lapot azzal a számmal, ahány CPU utasítás végrehajtódik, mielőtt hivatkozunk rá. Dobjuk ki azt a lapot, amelyikben legkisebb ez a szám. Egy baj van, nem lehet megvalósítani, viszont kétszeres futásnál tesztelési célokat szolgálhat. +\begin{itemize} + \item NRU (Not Recently Used) algoritmus: + \begin{itemize} + \item Használjuk a laptábla bejegyzés módosítás (Modify) és hivatkozás (Reference) bitjét. A hivatkozás bitet időnként (óramegszakításnál, kb. 0.02 sec) állítsuk 0-ra, ezzel azt jelezzük, hogy az ,,utóbbi időben" volt-e használva, hivatkozva. + \begin{itemize} + \item 0.osztály: nem hivatkozott, nem módosított + \item 1.osztály: nem hivatkozott, módosított. Ide akkor lehet kerülni, ha az óramegszakítás állítja 0-ra a hivatkozás bitet. + \item 2.osztály: hivatkozott, nem módosított + \item 3.osztály: hivatkozott, módosított + \end{itemize} + \item Válasszunk véletlenszerűen egy lapot a legkisebb nem üres osztályból. Egyszerű, nem igazán hatékony implementálni, megfelelő eredményt ad. + \end{itemize} + \item FIFO lapcserélés. Egyszerű FIFO, más területekről is ismert, ha szükség van egy új lapra akkor a legrégebbi lapot dobjuk ki. Listában az érkezés sorrendjében a lapok, egy lap a lista elejére érkezik, és a végéről távozik. Ennek javítása a Második Lehetőség lapcserélő algoritmus. + \item Második Lehetőség lapcserélő algoritmus. Olyan, mint a FIFO, csak ha a lista végén lévő lapnak a hivatkozás bitje 1, akkor kap egy második esélyt, a lista elejére kerül és a hivatkozás bitet 0-ra állítjuk. + \item Óra algoritmus: olyan, mint a második lehetőség, csak ne a lapokat mozgassuk körbe egy + listában, hanem rakjuk körbe őket és egy mutatóval körbe járunk. A mutató a legrégebbi lapra mutat. Laphibánál, ha a mutatott lap hivatkozás bitje 1, nullázzuk azt, és a következő lapot + vizsgáljuk. Ha vizsgált lap hivatkozás bitje 0, akkor kitesszük. + \item LRU (Least Recently Used) algoritmus: Legkevésbé (legrégebben) használt lap kidobása. HW vagy SW megvalósítás. + \begin{itemize} + \item HW1: Vegyünk egy számlálót, ami minden memória hivatkozásnál 1-gyel nő. Minden laptáblában tudjuk ezt a számlálót tárolni. Minden memóriahivatkozásnál ezt a számlálót beírjuk a lapba. Laphibánál megkeressük a legkisebb számlálóértékű lapot. + \item HW2: LRU bitmátrix használattal, n lap, n x n bitmátrix. Egy k. lapkeret hivatkozásnál állítsuk a mátrix k. sorát 1-re, míg a k. oszlopát 0-ra. Laphibánál a legkisebb értékű sor a legrégebbi. + \end{itemize} + \item NFU (Not Frequently Used) algoritmus: + \begin{itemize} + \item Minden laphoz tegyünk egy számlálót. Minden óramegszakításnál ehhez adjuk hozzá a lap + hivatkozás (R) bitjét. + \item Laphibánál a legkisebb számlálóértékű lapot dobjuk ki. (A leginkább nem használt lap) + \item Hiba, hogy az NFU nem felejt, egy program elején gyakran használt lapok megőrzik nagy értéküket. + \item Módosítsuk: Minden óramegszakításnál csináljunk jobbra egy biteltolást a számlálón, balról pedig hivatkozás bitet tegyük be (shr).(Öregítő algoritmus) + \item Ez jól közelíti az LRU algoritmust. + \item Ez a lapszámláló véges bitszámú (n), így n időegység előtti eseményeket biztosan nem tud megkülönböztetni. + \end{itemize} +\end{itemize} + +\section{Lemezterület-szervezés, redundáns tömbök, fájlrendszerek szolgáltatásai és jellemző megvalósításaik} + +\subsection{Lemezterület-szervezés} + +\subsection{Redundáns tömbök} + +RAID -- Redundant Array of Inexpensive Disks. Ha operációs rendszer nyújtja, gyakran Soft Raidnek nevezik. Ha intelligens (külső) vezérlőegység nyújtja, gyakran Hardver Raid-nek, vagy csak Raid diszkrendszernek nevezik. Bár nevében olcsó (Inexpensive), valójában inkább nem az. Több lemezt fog össze, és egy logikai egységként látja az operációs rendszer. Többféle ,,összefogási" elv létezik: RAID 0-6. +\begin{itemize} + \item RAID 0(striping) + \begin{itemize} + \item Ez az a Raid, ami nem is redundáns + \item Több lemez logikai összefűzésével egy meghajtót kapunk. + \item A lemezkapacitások összege adja az új meghajtó kapacitását. + \item A logikai meghajtó blokkjait szétrakja a lemezekre (striping), ezáltal egy fájl írása több lemezre kerül. + \item Gyorsabb I/O műveletek. + \item Nincs meghibásodás elleni védelem. + \end{itemize} + \item RAID 1(tükrözés) + \begin{itemize} + \item Két független lemezből készít egy logikai egységet. + \item Minden adatot párhuzamosan kiír mindkét lemezre.(Tükrözés, mirror) + \item Tárolókapacitás felére csökken. + \item Drága megoldás. + \item Jelentős hibatűrő képesség. Mindkét lemez egyszerre történő meghibásodása okoz adatvesztést. + \end{itemize} + \item RAID 1+0, RAID 0+1 + \begin{itemize} + \item RAID 1+0: Tükrös diszkekből vonjunk össze többet. + \item RAID 0+1: RAID 0 összevont lemezcsoportból vegyünk kettőt. + \item A vezérlők gyakran nyújtják egyiket, másikat, mivel így is, úgy is tükrözés van, azaz drága, így ritkán használt. + \end{itemize} + \item RAID 2: Adatbitek mellett hibajavító biteket is tartalmaz. (ECC: Error Correction Code) Pl. 4 diszkhez 3 javító diszk + \item RAID 3: Elég egy plusz ,,paritásdiszk", n+1 diszk, $\sum{n}$ a kapacitás + \item RAID 4: RAID 0 kiegészítése paritásdiszkkel. + \item Ma ezen megoldások (RAID 2,3,4) nem gyakran használatosak. + \item RAID 5 + \begin{itemize} + \item Nincs paritásdiszk, ez el van osztva a tömb összes elemére. (stripe set) + \item Adatok is elosztva kerülnek tárolásra. + \item Intenzív CPU igény (vezérlő CPU!!!) + \item Redundáns tárolás, 1 lemez meghibásodása nem okoz adatvesztést. A paritásbitből meg a többiből az egy eltűnt kiszámítható. 2 lemez egyidejű meghibásodása már okoz adatvesztést. + \item N lemez RAID 5 tömbben (N>=3), n-1 lemez méretű logikai meghajtót ad. + \end{itemize} + \item RAID 6 + \begin{itemize} + \item A RAID 5 paritásblokkhoz, hibajavító kód kerül tárolásra.(+1 diszk) + \item Még intenzívebb CPU igény. + \item Két diszk egyidejű kiesése sem okoz adatvesztést. + \item Relatív drága + \item N diszk RAID 6-os tömbjének kapacitása, N-2 diszk kapacitással azonos. + \item Elvileg általánosítható a módszer (3 diszk kiesése) + \end{itemize} +\end{itemize} +Ma leggyakrabban a RAID 1,5 verziókat használják. A RAID 6 vezérlők az utóbbi 1-2 évben jelentek meg. Bár olcsó diszkekről szól a RAID, de valójában ezek nem mindig olcsók. RAID 6-nl már 2 lemez kiesik, így ez még inkább drága. \\ +Hot-Swap(forró csere) RAID vezérlő: működés közben a meghibásodott lemezt egyszerűen kicseréljük. + +\subsection{Fájlrendszerek szolgáltatásai} + +\textit{Fájl}: adatok egy logikai csoportja, névvel egyéb paraméterekkel ellátva. A fájl az információtárolás egysége, névvel hivatkozunk rá. Jellemzően egy lemezen helyezkedik el, de általánosan az adathalmaz, adatfolyam akár képernyőhöz, billentyűzethez is köthető. \\ +A lemezen általában 3 féle fájl, állomány található: +\begin{itemize} + \item Rendes felhasználói állomány. + \item Ideiglenes állomány + \item Adminisztratív állomány. Ez a működéshez szükséges, általában rejtett. +\end{itemize} +\textit{Könyvtár}: fájlok (könyvtárak) logikai csoportosítása. \\ +\textit{Fájlrendszer}: módszer, a fizikai lemezünkön, kötetünkön a fájlok és könyvtárak elhelyezés rendszerének kialakítására. \\ +Fájlok elhelyezése: A partíció elején, az ún. Szuperblokk (pl. FAT esetén a 0. blokk ) leírja a rendszer jellemzőit. Általában következik a helynyilvántartás (FAT, láncolt listás nyilvántartás). Ezután a könyvtárszerkezet (inode), a könyvtár bejegyzésekkel, fájl adatokkal. (FAT16-nál a könyvtár előbb van, majd utána a fájl adatok.) \\ +Elhelyezési stratégiák: +\begin{itemize} + \item Folytonos tárkiosztás: First Fit, Best Fit, Worst Fit (olyan memória szakaszba tesszük, hogy a lehető legnagyobb rész maradjon szabadon). Veszteséges lemezkihasználás. + \item Láncolt elhelyezkedés: Nincs veszteség (csak a blokkméretből adódóan). Fájl adatok (blokkokra bontva) láncolt lista tábla. Az n. blokk olvasása lassú lesz. Szabad-foglalt szektorok: File Allocation Table,FAT. Ez nagy lehet, a FAT-nak a memóriában kell lenni fájl műveletnél. + \item Indextáblás elhelyezés: Katalógus tartalmazza a fájlhoz tartozó kis tábla (inode) címét. Egy inode címből elérhető a fájl. +\end{itemize} + +Fájlrendszer típusok: +\begin{itemize} + \item Merevlemezen alkalmazott fájlrendszer: FAT, NTFS, EXT2FS, XFS, stb + \item Szalagos rendszereken (elsősorban backup) alkalmazott fájlrendszer: Tartalomjegyzék, majd a tartalom szekvenciálisan + \item CD, DVD, Magneto-opto Disc fájlrendszer: CDFS, UDF (Universal Disc Format), kompatibilitás + \item RAM lemezek (ma már kevésbé használtak) + \item FLASH memória meghajtó (FAT32) + \item Hálózati meghajtó: NFS + \item Egyéb pszeudó fájlrendszerek: Zip, tar.gz, ISO +\end{itemize} + +\textit{Naplózott fájlrendszerek}: A fájlrendszer sérülés, áramszünet stb. esetén inkonzisztens állapotba kerülhet. Gyakran nevezik: LFS-nek (Log-structured File System) vagy JFS-nek(Journaled). Adatbázis-kezelők mintájára: művelet + log naplózódik. Tranzakciós alapra épül. Leállás, hiba esetén a log alapján helyre lehet állítani. Célszerűen a log másik lemez (másik partíció). Nagyobb erőforrás igényű, de nagyobb a megbízhatóság. \\ +A mai operációs rendszerek ,,rengeteg" típust támogatnak, pl: Linux 2.6 kernel több mint 50-et. +A fájlrendszert csatolni többféleképpen is lehet: +\begin{itemize} + \item Mount, eredményeképpen a fájlrendszer állományok elérhetők lesznek. + \item Automatikus csatolás (pl. USB drive) + \item Kézi csatolás (Linux, mount parancs) +\end{itemize} +Külön névtérbeli elérhetőség a Windowsnál az A, B, C stb lemezek. Egységes névtér a UNIX-nál van. + +\subsection{Fájlrendszerek szolgáltatásainak jellemző megvalósításai} + +\begin{itemize} + \item FAT + \begin{itemize} + \item File Allocation Table. Talán a legrégebbi, ma is élő fájlrendszer. + \item A FAT tábla a lemez foglaltsági térképe, annyi eleme van, ahány blokk a lemezen. Pl: Fat12, FDD, Cluster méret 12 bites. Ha értéke 0, szabad, ha nem, foglalt. Biztonság kedvéért 2 tábla van. + \item Láncolt elhelyezés. A katalógusban a file adatok (név stb) mellett csak az első fájl blokk sorszáma van megadva. A FAT blokk azonosító mutatja a következő blokk címét. Ha nincs tovább, FFF az érték. + \item Rögzített bejegyzés méret, 32 bájt (max. 8.3 név) + \item System, Hidden, Archive, Read only, könyvtár attribútumok + \item A fájl utolsó módosítás ideje is tárolva van. + \item \textit{FAT16}, 16 bites cluster leíró, 4 bájt (2x2) írja le a fájl kezdőblokkját. Max. 4 GB partíciós méret (64kb blokk méretnél), jellemzően 2 GB. Fájlméret maximum is a 4 (2) GB. Külön könyvtári terület (FDD-nez a 0. sáv). FDD-n 512 könyvtári bejegyzés. HDD-n 32736 könyvtári bejegyzés (16 bit előjelesen) + \item \textit{FAT32} (1996-tól elérhető): 28 bites clusterleíró, 2 TB partíciós méret (alap szektor mérettel), 32 MB-ig 1 blokk = 1 szektor(512bájt). 64 MB: 1 blokk=1KB (2 szektor), 128MB: 1 blokk=2KB. 1 blokk max. 64 KB lehet. + \item Támogatták már a hosszú fájl neveket is. Többszörös 8.3 részre fenntartott bejegyzésekkel. + \item Töredezettségmentesítés szükséges. + \end{itemize} + \item NTFS + \begin{itemize} + \item New Technology File System + \item FAT-NTFS hatékonysági határ: kb. 400 MB. + \item 255 karakteres fájl név, 8+3 másodlagos név + \item Kifinomult biztonsági beállítások + \item Ahogy a FAT esetén, itt is szükséges a töredezettségmentesítés. + \item Titkosított fájlrendszer támogatása, naplózás + \item POSIX támogatás. Hardlink (fsutil parancs), időbélyegek, kis-nagybetűk különböznek + \item Tömörített fájl, mappa, felhasználói kvóta kezelés + \item Az NTFS csak klasztereket tart nyilván, szektort (512bájt) nem + + \begin{figure}[H] + \centering + \includegraphics[width=0.9\textwidth]{img/ntfs.png} + \caption{NTFS partíció. A Master File Table és a File System Data egy-egy táblázat} + \end{figure} + + \item MFT: NTFS partíció az MFT (Master File Table) táblázattal kezdődik. 16 attribútum ad egy fájl bejegyzést. Minden attribútum max. 1kb. Ha ez nem elég, akkor egy attribútum mutat a folytatásra. Az adat is egyfajta attribútum, így egy bejegyzés több adatsort tartalmazhat. (PL: Betekintő kép) Elvi fájlméret $2^64$ bájt lehet. Ha a fájl < 1kb, belefér az attribútumba, közvetlen fájl. Nincs fájlméret maximum. + \end{itemize} + \begin{figure}[H] + \centering + \includegraphics[width=0.6\textwidth]{img/ntfs2.png} + \caption{Az NTFS partíció felépítése} + \end{figure} + \item ext, az ext2 és az ext3 + \begin{itemize} + \item Az „ext” kifejezés a fájlrendszerek neveiben az extended (magyarul kiterjesztett) kifejezést takarja. Az extended fájlrendszer volt az első kifejezetten a UNIX-szerű GNU/LINUX operációs rendszerekhez készített fájlrendszer, amely örökölte az UFS (UNIX File System) fájlrendszer metaadat-szerkezetét, és arra készült, hogy a Minix operációs rendszer fájlrendszerének a hibáit kiküszöbölje. A hibák kiküszöbölése többek között a Minix operációs rendszer fájlrendszer-határainak kiterjesztése. + \item Az ext2 fájlrendszer, amely a GNU/LINUX operációs rendszereken kívül más rendszereken is megjelent, több Linux disztribúció alapértelmezett fájlrendszere volt, amíg az utódja, az „ext3” fájlrendszer (third extended filesystem – harmadik kiterjesztett fájlrendszer) el nem készült. + \item Az ext3 fájlrendszer (third extended filesystem – harmadik kiterjesztett fájlrendszer) az ext2 fájlrendszer utódja, amely már az ext2 fájlrendszerhez képest naplózást is tartalmaz. Ez a naplózás elsősorban a biztonságot növeli, és lehetővé teszi azt, hogy szabálytalan leállás bekövetkezése után ne kelljen az egész fájlrendszert újra ellenőrizni. + \end{itemize} + \item ReiserFS: A ReiserFS fájlrendszer lehetővé teszi egy blokkos eszközön (block device) változó méretű fájlok tárolását és könyvtárstruktúrába rendezését. A kezdeti UNIX és UNIX-szerű operációs rendszerek (így pl. a GNU/LINUX operációs rendszer is) csak egyfajta fájlrendszert támogattak, a saját formátumukat. A modern operációs rendszerek viszont többféle fájlrendszert is támogatnak, és vannak olyan fájlrendszerek is, amelyeket több operációs rendszer is támogat. A ReiserFS fájlrendszer egyáltalán nem ilyen. A ReiserFS fájlrendszer egy olyan fájlrendszer, amely csak és kizárólag a GNU/LINUX operációs rendszer alatt használható jelenleg korlátozás nélkül. +\end{itemize} + +\end{document} \ No newline at end of file diff --git a/15.Operációs rendszerek/img/allapot.png b/17. Operációs rendszerek/img/allapot.png similarity index 100% rename from 15.Operációs rendszerek/img/allapot.png rename to 17. Operációs rendszerek/img/allapot.png diff --git a/15.Operációs rendszerek/img/filo.png b/17. Operációs rendszerek/img/filo.png similarity index 100% rename from 15.Operációs rendszerek/img/filo.png rename to 17. Operációs rendszerek/img/filo.png diff --git a/15.Operációs rendszerek/img/fogyaszto_szemafor.png b/17. Operációs rendszerek/img/fogyaszto_szemafor.png similarity index 100% rename from 15.Operációs rendszerek/img/fogyaszto_szemafor.png rename to 17. Operációs rendszerek/img/fogyaszto_szemafor.png diff --git a/15.Operációs rendszerek/img/gyarto_szemafor.png b/17. Operációs rendszerek/img/gyarto_szemafor.png similarity index 100% rename from 15.Operációs rendszerek/img/gyarto_szemafor.png rename to 17. Operációs rendszerek/img/gyarto_szemafor.png diff --git a/15.Operációs rendszerek/img/iro.png b/17. Operációs rendszerek/img/iro.png similarity index 100% rename from 15.Operációs rendszerek/img/iro.png rename to 17. Operációs rendszerek/img/iro.png diff --git a/15.Operációs rendszerek/img/mutex.png b/17. Operációs rendszerek/img/mutex.png similarity index 100% rename from 15.Operációs rendszerek/img/mutex.png rename to 17. Operációs rendszerek/img/mutex.png diff --git a/15.Operációs rendszerek/img/ntfs.png b/17. Operációs rendszerek/img/ntfs.png similarity index 100% rename from 15.Operációs rendszerek/img/ntfs.png rename to 17. Operációs rendszerek/img/ntfs.png diff --git a/15.Operációs rendszerek/img/ntfs2.png b/17. Operációs rendszerek/img/ntfs2.png similarity index 100% rename from 15.Operációs rendszerek/img/ntfs2.png rename to 17. Operációs rendszerek/img/ntfs2.png diff --git a/15.Operációs rendszerek/img/olvaso.png b/17. Operációs rendszerek/img/olvaso.png similarity index 100% rename from 15.Operációs rendszerek/img/olvaso.png rename to 17. Operációs rendszerek/img/olvaso.png diff --git a/15.Operációs rendszerek/img/pekvasarlo.png b/17. Operációs rendszerek/img/pekvasarlo.png similarity index 100% rename from 15.Operációs rendszerek/img/pekvasarlo.png rename to 17. Operációs rendszerek/img/pekvasarlo.png diff --git a/15.Operációs rendszerek/img/peterson.png b/17. Operációs rendszerek/img/peterson.png similarity index 100% rename from 15.Operációs rendszerek/img/peterson.png rename to 17. Operációs rendszerek/img/peterson.png diff --git a/15.Operációs rendszerek/img/petersonhiba.png b/17. Operációs rendszerek/img/petersonhiba.png similarity index 100% rename from 15.Operációs rendszerek/img/petersonhiba.png rename to 17. Operációs rendszerek/img/petersonhiba.png diff --git a/15.Operációs rendszerek/img/szigoru.png b/17. Operációs rendszerek/img/szigoru.png similarity index 100% rename from 15.Operációs rendszerek/img/szigoru.png rename to 17. Operációs rendszerek/img/szigoru.png diff --git a/18. Számítógépes hálózatok és Internet eszközök/18. Számítógépes hálózatok és Internet eszközök.pdf b/18. Számítógépes hálózatok és Internet eszközök/18. Számítógépes hálózatok és Internet eszközök.pdf new file mode 100644 index 0000000..6a9668e Binary files /dev/null and b/18. Számítógépes hálózatok és Internet eszközök/18. Számítógépes hálózatok és Internet eszközök.pdf differ diff --git a/18. Számítógépes hálózatok és Internet eszközök/18. Számítógépes hálózatok és Internet eszközök.tex b/18. Számítógépes hálózatok és Internet eszközök/18. Számítógépes hálózatok és Internet eszközök.tex new file mode 100644 index 0000000..dadc648 --- /dev/null +++ b/18. Számítógépes hálózatok és Internet eszközök/18. Számítógépes hálózatok és Internet eszközök.tex @@ -0,0 +1,1046 @@ +\documentclass[margin=0px]{article} + +\usepackage{listings} +\usepackage[utf8]{inputenc} +\usepackage{graphicx} +\usepackage{float} +\usepackage[a4paper, margin=0.7in]{geometry} +\usepackage{subcaption} +\usepackage{amsthm} +\usepackage{amssymb} +\usepackage{amsmath} +\usepackage{color} +\usepackage{fancyhdr} +\usepackage{setspace} + +\onehalfspacing + +\renewcommand{\figurename}{ábra} +\newenvironment{tetel}[1]{\paragraph{#1 \\}}{} +\newcommand{\R}{\mathbb{R}} + +\pagestyle{fancy} +\lhead{\it{PTI BSc Záróvizsga tételek}} +\rhead{18. Számítógépes hálózatok és Internet eszközök} + +\title{\textbf{{\Large ELTE IK - Programtervező Informatikus BSc} \vspace{0.2cm} \\ {\huge Záróvizsga tételek}} \vspace{0.3cm} \\ 18. Számítógépes hálózatok és Internet eszközök} +\author{} +\date{} + +\begin{document} +\maketitle + +\begin{tetel}{Számítógépes hálózatok és Internet eszközök} + Rétegmodellek. Fizikai réteg: alapsáv, szélessáv, digitális kódolások, moduláció. Adatkapcsolati réteg: keretezés, hiba felügyelet (észlelés, javítás), CRC, forgalomszabályozás, dinamikus csatornakiosztás. Hálózati réteg: távolságvektor protokoll (distance vector), kapcsolatállapot protokoll (link-state), BGP, útvonal-vektor protokoll, IPv4 vs IPv6. Szállítói réteg: UDP, TCP (kapcsolat kezelés, torlódás); Alkalmazási réteg: DNS, HTTP, DHCP, ARP. +\end{tetel} + +\section{Hálózatok modelljei} +\begin{description} + \item[TCP/IP modell] \hfill \\ + \textbf{T}ransmission \textbf{C}ontrol \textbf{P}rotocol/\textbf{I}nternet \textbf{P}rotocol. Röviden TCP/IP. A TCP/IP modell 1982-ben lett az amerikai hadászati célú számítógépes hálózatok standardja. 1985-től népszerűsítették kereskedelmi használatra. + + 4 Réteget különböztet meg: + \begin{enumerate} + \item Kapcsolati réteg + \item Hálózati réteg + \item Szállítói réteg + \item Alkalmazási réteg + \end{enumerate} + \item[OSI modell] \hfill \\ + \textbf{O}pen \textbf{S}ystem \textbf{I}nterconnection Reference Model. Röviden OSI referencia modell. Standard koncepcionális modellt definiál kommunikációs hálózatok belső funkcionalitásához. + + 7 Réteget különböztet meg: + \begin{enumerate} + \item Fizikai réteg + \item Adatkapcsolati réteg + \item Hálózati réteg + \item Szállítási réteg + \item Munkamenet réteg + \item Megjelenítési réteg + \item Alkalmazási réteg + \end{enumerate} +\end{description} +\section{Fizikai réteg} +\begin{description} + \item[Definíció] \hfill \\ + A fizikai réteg feladata a bitek továbbítása a kommunikációs csatornán keresztül. Azaz a korrekt bit átvitel biztosítása, a kapcsolat kezelése és az átvitelhez szükséges idő és egyéb részletek tisztázása. \\ + Tehát a tervezési szempontok az interfész mechanikai, elektromos és eljárási kérdéseire, illetve az átviteli közegre vonatkoznak. + \item[Adatátvitel] \hfill + \begin{description} + \item[Vezetékes] \hfill \\ + Adatátvitel vezeték esetén valamilyen fizikai jellemző változtatásával lehetséges (pl.: feszültség, áramerősség). Ezt egy $g(t)$ periodikus függvénnyel jellemezhetjük. + \begin{align*} + g(t) = \frac{1}{2}c+ \sum\limits_{n=1}^\infty a_nsin(2\pi n f t) + \sum\limits_{n=1}^\infty b_ncos(2\pi n f t) + \end{align*} + ahol $f=\frac{1}{T}$ az alapfrekvencia, $a_n$ és $b_n$ pedig az $n$-edik harmonikus szinuszos illetve koszinuszos amplitúdók + \item[Vezetékes nélküli] \hfill \\ + Vezeték nélküli adatátvitelre sok helyen használnak elektormágneses hullámokat. A hullámoknak van frekvenciája és hullámhossza. + \begin{itemize} + \item Frekvencia: + A hullám másodpercenkénti rezgésszáma. Jele: $f$, mértékegysége: Hz (Hertz) + \item Hullámhossz: két egymást követő hullámcsúcs (v. hullámvölgy) közötti távolság. Jele: $\lambda$ + \end{itemize} + \begin{align*} + \lambda f = c + \end{align*} + ahol $c$ a fénysebesség, azaz az elektromágneses hullámok terjedési sebessége vákuumban. + \begin{figure}[H] + \centering + \includegraphics[width=0.6\textwidth]{img/elektromagneses.png} + \caption{Elektromágneses spektrum} + \end{figure} + \item[Szimbólumok] \hfill \\ + Bitek helyett szimbólumokat küldünk át. (Pl. 4 szimbólum: A - 00, B - 01, C - 10, D - 11)\\ + Baud: szimbólum/másodperc \\ + Adatráta: bit/másodperc + \item[Szinkronizáció] \hfill \\ + Kérdés: Mikor kell szignálokat mérni, illetve mikor kezdődik egy szimbólum? Ehhez szinkronizáció kell a felek között. + \begin{itemize} + \item Explicit órajel \\ + Párhuzamos átviteli csatornák használata, szinkronizált adatok, rövid átvitel esetén alkalmas. + \item Kritikus időpontok \\ + Szinkronizáljunk például egy szimbólum vagy blokk kezdetén, a kritikus időpontokon kívül szabadon futnak az órák, feltesszük, hogy az órák rövid ideig szinkronban futnak. + \item Szimbólum kódok \\ + Önütemező jel–külön órajel szinkronizáció nélkül dekódolható jel, a szignál tartalmazza a szinkronizáláshoz szükséges információt. + \end{itemize} + \begin{figure}[H] + \centering + \includegraphics[width=0.6\textwidth]{img/szinkronizacio.png} + \caption{Szinkronizáció szükségessége} + \end{figure} + \end{description} + \item[Átviteli közegek] \hfill \\ + \begin{description} + \item[Vezetékes] \hfill + \begin{itemize} + \item mágneses adathordozók \\ + sávszélesség jó, késleltetés nagy + \item sodort érpár \\ + Főként távbeszélőrendszerekben használatos; dupla rézhuzal; analóg és digitális jelátvitel + \item Koaxális kábel\\ + Nagyobb sebesség és távolság érhető el, mint a sodorttal; analóg és + digitális jelátvitel + \item Fényvezető szálak\\ + Fényforrás, átviteli közeg és detektor; fényimpulzus 1-es bit, nincs + fényimpulzus 0-s bit + \end{itemize} + \item[Vezetékes nélküli] \hfill + \begin{itemize} + \item Rádiófrekvenciás átvitel \\ + egyszerűen előállíthatóak; nagy távolság; kültéri és beltéri alkalmazhatóság; frekvenciafüggő terjedési jellemzők + \item Mikrohullámú átvitel\\ + egyenes vonal mentén terjed; elhalkulás problémája; nem drága + \item Infravörös és milliméteres hullámú átvitel \\ + kistávolságú átvitel esetén; szilárd tárgyakon nem hatol át + \item Látható fényhullámú átvitel\\ + lézerforrás + fényérzékelő; nagy sávszélesség, olcsó, nem engedélyköteles; időjárás erősen befolyásolhatja + \end{itemize} + \end{description} + \item[Jelátvitel] \hfill + \begin{itemize} + \item Alapsáv \\ + A digitális jel direkt árammá vagy feszültséggé alakul. A jel minden frekvencián átvitelre kerül. Átviteli korlátok + \begin{figure}[H] + \centering + \includegraphics[width=0.8\textwidth]{img/alapsav.png} + \caption{Digitális alapsávú átvitel struktúrája} + \end{figure} + \item Szélessáv \\ + Széles frekvencia tartományban történik az átvitel. A jel modulálására az alábbi lehetőségeket használhatjuk. + \begin{figure}[H] + \centering + \includegraphics[width=0.8\textwidth]{img/szelessav.png} + \caption{Digitális szélessávú átvitel struktúrája} + \end{figure} + + Modulációk:\\ + Egy szinuszos rezgés ábrázolása $T$ periódus idejű függvényre $g(t)=Asin(2\pi f t + \varphi)$ , ahol $A$ az amplitúdó, $f = \frac{1}{T}$ a frekvencia és $\varphi $ a fáziseltolás + \begin{itemize} + \item Amplitúdó moduláció \\ + Az $s(t)$ szignált a szinusz görbe amplitúdójaként kódoljuk, azaz: + \begin{align*} + f_A(t) = s(t) \cdot sin(2\pi f t + \varphi) + \end{align*} + Analóg szignál: amplitúdó moduláció\\ + Digitális szignál: amplitúdó keying(szignál erőssége egy diszkrét halmaz értékeinek megfelelően változik) + \begin{figure}[H] + \centering + \includegraphics[width=0.5\textwidth]{img/amplitudo_mod.png} + \caption{Amplitúdó moduláció} + \end{figure} + \begin{figure}[H] + \centering + \includegraphics[width=0.5\textwidth]{img/amplitudo_key.png} + \caption{Amplitúdó keying} + \end{figure} + \item Frekvencia moduláció \\ + Az $s(t)$ szignált a szinusz görbe frekvenciájában kódoljuk, azaz: + \begin{align*} + f_F(t) = a \cdot sin(2\pi s(t) t + \varphi) + \end{align*} + Analóg szignál: frekvencia moduláció\\ + Digitális szignál: frekvencia-eltolás keying(például egy diszkrét halmaz szimbólumaihoz különböző frekvenciák hozzárendelésével) + \begin{figure}[H] + \centering + \includegraphics[width=0.5\textwidth]{img/frekvencia_mod.png} + \caption{Frekvencia moduláció} + \end{figure} + \begin{figure}[H] + \centering + \includegraphics[width=0.5\textwidth]{img/frekvencia_key.png} + \caption{Frekvencia keying} + \end{figure} + \item Fázis moduláció \\ + Az $s(t)$ szignált a szinusz görbe fázisában kódoljuk, azaz: + \begin{align*} + f_P(t) = a \cdot sin(2\pi f t + s(t)) + \end{align*} + Analóg szignál: fázis moduláció (nem igazán használják)\\ + Digitális szignál: fázis-eltolás keying ( például egy diszkrét halmaz szimbólumaihoz különböző fázisok hozzárendelésével) + \begin{figure}[H] + \centering + \includegraphics[width=0.5\textwidth]{img/fazis_mod.png} + \caption{Fázis moduláció} + \end{figure} + \begin{figure}[H] + \centering + \includegraphics[width=0.5\textwidth]{img/fazis_key.png} + \caption{Fázis-eltolás keying} + \end{figure} + \end{itemize} + + Digitális és analóg jelek összehasonlítása: \\ + Digitális átvitel: Diszkrét szignálok véges halmazát + használja (például feszültség vagy áramerősség + értékek).\\ + Analóg átvitel: Szignálok folytonos halmazát használja + (például feszültség vagy áramerősség a vezetékben) \\ + Digitális esetében lehetőség van a vételpontosság helyreállítására illetve az eredeti jel helyreállítására, míg az analógnál a fellépő hibák önmagukat erősíthetik. + \end{itemize} +\end{description} +\section{Adatkapcsolati réteg} +\begin{description} + \item[Definíció] \hfill \\ + Az adatkapcsolati réteg feladata jól definiált szolgálati interfész biztosítása a hálózati rétegnek, melynek három fázisa van: + \begin{itemize} + \item nyugtázatlan összeköttetés alapú szolgálat + \item nyugtázott összeköttetés nélküli szolgálat + \item nyugtázott összeköttetés alapú szolgálat + \end{itemize} + Továbbá az átviteli hibák kezelése és az adatforgalom szabályozása (elárasztás elkerülése). + \item[Keretképzés] \hfill \\ + A fizikai réteg nem garantál hibamentességet, az adatkapcsolati réteg feladata a hibajelzés illetve a szükség szerint javítás. Erre megoldás: keretekre tördelése a bitfolyamnak, és ellenőrző összegek számítása. A keretezés nem egyszerű feladat, mivel megbízható időzítésre nem nagyon van lehetőség. Négy lehetséges módszer: + \begin{enumerate} + \item Karakterszámlálás \\ + A keretben lévő karakterek számát a keret fejlécében adjuk meg. Így a vevő adatkapcsolati rétege tudni fogja a keret végét. Probléma: nagyon érzékeny a hibára a módszer. + \begin{figure}[H] + \centering + \includegraphics[width=0.7\textwidth]{img/karakterszamlalas.png} + \caption{Karakterszámlálás} + \end{figure} + \item Kezdő és végkarakterek karakterbeszúrással \\ + Különleges bájtokat helyezünk el a keret elejének és végének jelzésére, aminek a neve jelző bájt(flagbyte). Az adatfolyamban szereplő speciális bájtokhoz ESC bájtot használnak. + \begin{figure}[H] + \centering + \includegraphics[width=0.6\textwidth]{img/karakterbeszuras.png} + \caption{Kezdő és végkarakterek karakterbeszúrással} + \end{figure} + \item Kezdő és végjelek bitbeszúrása \\ + Minden keret egy speciális bitmintával kezdődik (flagbájt, 01111110) és minden egymást követő 5 hosszú folytonos 1-es bit sorozat után beszúr egy 0-át. + \begin{figure}[H] + \centering + \includegraphics[width=0.9\textwidth]{img/bitbeszuras.png} + \caption{Kezdő és végjelek bitbeszúrásal} + \end{figure} + \item Fizikai rétegbeli kódolás-sértés \\ + Olyan hálózatokban használható, ahol a fizikai rétegbeli kódolás redundanciát tartalmaz. + \end{enumerate} + \item[Hibakezelés] \hfill \\ + Hibakezelés szempontjából a következő két esetet kell vizsgálnunk. A keretek megérkeztek-e a célállomás hálózati rétegéhez, illetve helyes sorrendben érkeztek-e meg. Ehhez valamilyen visszacsatolás szükséges a vevő és az adó között. (például nyugták). Időkorlátokat vezetünk be az egyes lépésekhez. Hiba estén a csomagot újraküldjük. Többszörös vétel lehet, amin segíthet a sorszámok használata. Az adatkapcsolati réteg feladata a hibakezelés szempontjából, hogy az időzítőket és számlálókat úgy kezelje, hogy biztosítani tudja a keretek pontosan egyszeri (nem több és nem kevesebb) megérkezését a célállomás hálózati rétegéhez. + + Bithibák: + \begin{itemize} + \item egyszerű bithiba \\ + Az adategység 1 bitje nulláról egyre avagy egyről nullára változik. + \begin{figure}[H] + \centering + \includegraphics[width=0.2\textwidth]{img/egyszeru_bithiba.png} + \caption{Egyszerű bithiba} + \end{figure} + \item csoportos bithiba \\ + Egy olyan folytonos szimbólum sorozatot, amelynek az első és utolsó szimbóluma hibás, és nem létezik ezen két szimbólummal határolt részsorozatban olyan $m$ hosszú részsorozat, amelyet helyesen fogadtunk, $m$ hosszú csoportos bithibának nevezünk. + \end{itemize} + + Hiba jelzés és javítás:\\ + Kétféle hibakezelési stratégia létezik. Ezek a hibajelző (redundáns információ mellékelése) és hibajavító kódok (adatok közé iktatott redundancia). + [Megbízható csatornákon a hibajelzés olcsóbb. (csomagot inkább újraküldjük). A kevésbé megbízható csatornákon a hibajavításos módszer célszerűbb] + \begin{itemize} + \item Hamming-távolság, Hamming-korlát \\ + Küldendő keret $m$ bitet tartalmaz. Redundáns bitek száma $r$. Tehát az elküldött keret: $n = m+r$ bit. + + Hamming-távolság: \\ + Az olyan bitpozíciók számát, amelyeken a két kódszóban különböző bitek állnak, a két kódszó Hamming távolságának nevezzük. Jelölés: $d(x,y)$\\ + Legyen $S$ az egyenlő hosszú bitszavak halmaza. $S$ Hamming-távolsága: + \begin{align*} + d(S) := \min_{x,y, \in S \ \land \ x \neq y} d(x,y) + \end{align*} + + d(S) = 1 esetén: \\ + Nincs hibafelismerés, ugyanis megengedett kódszóból 1 bit megváltoztatásával megengedett kódszó áll elő. + \begin{figure}[H] + \centering + \includegraphics[width=0.4\textwidth]{img/hamming1.png} + \caption{Kód Hamming-távolsága = 1} + \end{figure} + d(S) = 2 esetén: \\ + Ha az $x$ kódszóhoz létezik olyan $v$ nem megengedett kódszó, amelyre $d(u,x)=1$, akkor hiba történt. Ha $x$ és $y$ megengedett kódszavak (távolságuk minimális = 2), akkor a következő összefüggésnek teljesülnie kell: + \begin{align*} + 2 = d(x,y) \leq d(x,v)+d(v,y) + \end{align*} + Azaz egy bithiba felismerhető, de nem javítható. + \begin{figure}[H] + \centering + \includegraphics[width=0.4\textwidth]{img/hamming2.png} + \caption{Kód Hamming-távolsága = 2} + \end{figure} + + d(S) = 3 esetén: \\ + Ekkor minden $u$, melyre $d(x,u)=1$ és $d(u,y) > 1$ nem megengedett. Ekkor három lehetőség áll fent: + \begin{itemize} + \item x került átvitelre és 1 bit hibával érkezett + \item y került átvitelre és 2 bit hibával érkezett + \item valami más került átvitelre és legalább 2 bit hibával érkezett + \end{itemize} + De valószínűbb, hogy $x$ került átvitelre, tehát ez egy 1 bit hiba javító, 2 bit hiba felismerő kód. + \begin{figure}[H] + \centering + \includegraphics[width=0.4\textwidth]{img/hamming3.png} + \caption{Kód Hamming-távolsága = 3} + \end{figure} + + Hamming-korlát: \\ + $ C \subseteq \{0,1\}^n$ és $d(C) = k$. Ekkor a kódszavak $\frac{k-1}{2}$ sugarú környezeteiben található bitszavak egymással diszjunkt halmazainak uniója legfeljebb az $n$-hosszú bitszavak halmazát adhatja ki. Vagyis formálisan: + \begin{align*} + |C|\sum_{i=0}^{\lfloor\frac{k-1}{2}\rfloor}\dbinom{n}{i} \leq 2^n + \end{align*} + + \begin{itemize} + \item Hibafelismerés: \\ + $d$ bit hiba felismeréséhez a keretek halmazában legalább $d+1$ Hamming távolság szükséges. + + \item Hibajavítás: \\ + $d$ bit hiba javításához a megengedett keretek halmazában legalább $2d+1$ Hamming távolság szükséges. + + \item Kód rátája: \\ + $R_S = \frac{log_2|S|}{n}$ a kód rátája ($S \subseteq \{0,1\}^n$) - hatékonyságot karakterizálja + + \item Kód távolsága: \\ + $\delta_S = \frac{d(S)}{n}$ a kód távolsága ($S \subseteq \{0,1\}^n$) - hibakezelést karakterizálja + \end{itemize} + A jó kódnak a rátája és a távolsága is nagy. + \item Paritásbit \\ + A paritásbit olyan bit, melyet a kódszóban lévő egyesek száma alapján választunk. + \begin{itemize} + \item Odd Parity - ha az egyesek száma páratlan, akkor 0 befűzése; egyébként 1-es befűzése + \item Even Parity - ha az egyesek száma páros, akkor 0 befűzése; egyébként 1-es befűzése + \end{itemize} + Egy paritást használó módszer az ún. Hamming módszer:\\ + A kódszó bitjeit számozzuk meg (1-gyel kezdődően). A 2 hatványú pozíciókon az ellenőrző bitek kapnak helyet, a maradék helyekre az üzenet bitjei kerülnek. Mindegyik ellenőrző bit a bitek egy csoportjának (beleértve önmagát is) a paritását állítja be párosra (vagy páratlanra).\\ + A csoportok a következőképp alakulnak: + \begin{itemize} + \item 1. bit: Minden első egyhosszú bitsorozat az első bittől kezdve (tehát: 1,3,5,7,...) + \item 2. bit: Minden első kéthosszú bitsorozat a második bittől kezdve (tehát: 2-3,6-7,10-11) + \item 4. bit: Minden első négyhosszú bitsorozat a negyedik bittől kezdve (tehát: 4-7,12-15) + \item stb. + \end{itemize} + \begin{figure}[H] + \centering + \includegraphics[width=0.8\textwidth]{img/paritasbit.png} + \caption{Paritásbitek csoportjai} + \end{figure} + Példa:\\ + Legyen az átküldendő üzenet: 1000101 \\ + Ekkor a kódszó a következőképp alakul: \\ + {\color[rgb]{1,0,0}$\heartsuit\heartsuit$}1{\color[rgb]{1,0,0}$\heartsuit$}000{\color[rgb]{1,0,0}$\heartsuit$}101\\ + A 8. bit a 8-11 bitsorozat paritását állítja be párosra:\\ + {\color[rgb]{1,0,0}$\heartsuit\heartsuit$}1{\color[rgb]{1,0,0}$\heartsuit$}000{\color[rgb]{0,0,1}0101}\\ + A 4. bit a 4-7 bitsorozat paritását állítja be párosra:\\ + {\color[rgb]{1,0,0}$\heartsuit\heartsuit$}1{\color[rgb]{0,0,1}0000}0101\\ + A 2. bit a 2-3, 6-7, 10-11 bitsorozat paritását állítja be párosra:\\ + {\color[rgb]{1,0,0}$\heartsuit$}{\color[rgb]{0,0,1}01}00{\color[rgb]{0,0,1}00}01{\color[rgb]{0,0,1}01}\\ + Az 1. bit az 1,3,5,7,9,11 bitsorozat paritását állítja be párosra: \\ + {\color[rgb]{0,0,1}1}0{\color[rgb]{0,0,1}1}0{\color[rgb]{0,0,1}0}0{\color[rgb]{0,0,1}0}0{\color[rgb]{0,0,1}1}0{\color[rgb]{0,0,1}1}\\ + + Tehát a elküldendő bitsorozat: + {\color[rgb]{1,0,0}10}1{\color[rgb]{1,0,0}0}000{\color[rgb]{1,0,0}0}101\\ + + \item CRC - Polinom-kód, azaz ciklikus redundancia \\ + A bitsorozatokat egy $\mathbb{Z}_2$ feletti polinom ($M(x)$) együtthatóinak tekintjük. Definiálunk egy $G(x)$ $r$ fokú generátorpolinomot, melyet a vevő és küldő egyaránt ismer. + \begin{enumerate} + \item Fűzzünk $r$ darab 0 bitet a keret alacsony helyi értékű végéhez. Azaz vegyük az $x^rM(x)$ polinomot (ez már $m+r$ fokú) + \item Osszuk el $x^rM(x)$-et $G(x)$-szel (mod 2). + \item A maradékot (mely mindig r vagy kevesebb bitet tartalmaz) vonjuk ki $x^rM(x)$-ből (mod 2). Így az eredeti keret végére egy r hosszú ellenőrző összeg kerül. Legyen ez a polinom $T(x)$. + \item A vevő egy $T(x)+E(x)$-nek megfelelő polinomot kap (ahol $E(x)$ a hiba polinom). Ezt elosztva a generátorpolinommal egy $R(x)$ polinomot kapunk. Ha ez a polinom nem nulla, akkor hiba történt. + \end{enumerate} + A $G(x)$ többszöröseinek megfelelő bithibákat nem ismerjük fel. + \end{itemize} + \item[Protokollok] \hfill + \begin{description} + \item[Elemi adatkapcsolati protokollok] \hfill + \begin{itemize} + \item Korlátozás nélküli szimplex protokoll\\ + Környezet: + \begin{itemize} + \item Adó, vevő: mindig kész. + \item Nincs feldolgozási idő + \item Végtelen puffer + \item Nincs keret rontás, vesztés + \end{itemize} + + Protokoll: + \begin{itemize} + \item Nincs sorszám/nyugta + \item Küldő végtelen ciklusban küldi kifele a kereteket folyamatosan + \item A vevő kezdetben várakozik az első keret megérkezésére, keret érkezésekor a hardver puffer tartalmát változóba teszi és az adatrészt továbbküldi a hálózati rétegnek. + \end{itemize} + \item Szimplex megáll és vár protokoll \\ + Környezet: + \begin{itemize} + \item Adó, vevő hálózati rétegei: mindig kész. + \item A vevőnek $\delta t$ időre van szüksége a bejövő keret feldolgozására. + \item Nincs pufferelés és sorban állás sem + \item Nincs keret rontás, vesztés + \end{itemize} + + Protokoll: + \begin{itemize} + \item Nincs sorszám/nyugta + \item Küldő egyesével küld, következőt csak a nyugtát követően. + \item A vevő kezdetben várakozik az első keret megérkezésére, keret érkezésekor a hardver puffer tartalmát változóba teszi és az adatrészt továbbküldi a hálózati rétegnek, végül nyugtázza a keretet. + \end{itemize} + \item Szimplex protokoll zajos csatornához\\ + Környezet: + \begin{itemize} + \item Adó, vevő hálózati rétegei: mindig kész. + \item A vevőnek $\delta t$ időre van szüksége a bejövő keret feldolgozására. + \item Nincs pufferelés és sorban állás sem + \item Keret sérülhet, elveszhet + \end{itemize} + + Protokoll: + \begin{itemize} + \item Nincs sorszám/nyugta + \item Küldő egyesével küld, addig nem küld újat, míg határidőn belül nyugtát nem kap. Határidő után újraküldi a keretet. + \item A vevő kezdetben várakozik az első keret megérkezésére, keret érkezésekor a hardver puffer tartalmát változóba teszi, leellenőrzi a kontroll összeget: + \begin{itemize} + \item Nincs hiba: az adatrészt továbbküldi a hálózati rétegnek, végül nyugtázza a keretet. + \item Van hiba: eldobja a keretet és nem nyugtáz + \end{itemize} + \end{itemize} + \end{itemize} + \item[Csúszóablakos protokoll] \hfill \\ + Egy adott időpontban egyszerre több keret is átviteli állapotban lehet. A fogadó $n$ keretnek megfelelő méretű puffert allokál. A küldőnek legfeljebb $n$, azaz ablak méretnyi, nyugtázatlan keretet küldése engedélyezett. A keret sorozatbeli pozíciója adja a keret címkéjét. (sorozatszám). + A fogadónak a hibás, illetve a nem megengedett sorozatszámmal érkező kereteket el kell dobnia. A küldő nyilvántartja a küldhető sorozatszámok halmazát (adási ablak). A fogadó nyilvántartja a fogadható sorozatszámok halmazát (vételi ablak). Az adási ablak minden küldéssel szűkül, illetve nő egy nyugta érkezésével. + + Mi van ha egy hosszú folyam közepén történik egy keret hiba? + \begin{enumerate} + \item "visszalépés N-nel" stratégia\\ + Az összes hibás keret utáni keretet eldobja és nyugtát sem küld róluk. Mikor az adónak lejár az időzítője, akkor újraküldi az összes nyugtázatlan keretet, kezdve a sérült vagy elveszett kerettel. Hátrány: Nagy sávszélességet pazarolhat el, ha nagy a hibaarány. + \item "szelektív ismétlés" stratégia \\ + A hibás kereteket eldobja, de a jó kereteket a hibás után puffereli. Mikor az adónak lejár az időzítője, akkor a legrégebbi nyugtázatlan keretet küldi el újra. Hátrány: Nagy memória igény nagy vételi ablak esetén. + \end{enumerate} + + \item[Példák adatkapcsolati protokollokra] \hfill + \begin{itemize} + \item HDLC - High-level Data Link Control \\ + A HDLC protokoll 3 bites csúszó-ablak protokollt alkalmaz a sorszámozáshoz. + Három típusú keretet használ: + \begin{itemize} + \item információs + \item felügyelő + \begin{itemize} + \item nyugtakeret (RECIEVE READY) + \item negatív nyugta keret (REJECT) + \item vételre nem kész (RECIEVE NOT READY) - nyugtáz minden keretet a következőig + \item szelektív elutasítás (SELECTIVE REJECT) - egy gy adott keret újraküldésére szólít fel + \end{itemize} + \item Számozatlan + \end{itemize} + + Általános keretfelépítése: + \begin{itemize} + \item FLAG bájt a keret határok jelzésére + \item \textit{cím} mező - több vonallal rendelkező terminálok esetén van jelentősége + \item \textit{vezérlés} mező - sorszámozás, nyugtázás és egyéb feladatok ellátására + \item \textit{adat} mező - tetszőleges hosszú adat lehet + \item \textit{ellenőrző összeg} mező - CRC kontrollösszeg (CRC-CCITT generátor polinom felhasználásával) + \end{itemize} + \begin{figure}[H] + \centering + \includegraphics[width=0.8\textwidth]{img/hdlc_keret.png} + \caption{HDLC keret felépítése} + \end{figure} + \item PPP - Point-to Point Protocol \\ + A PPP protokoll három dolgot biztosít: + \begin{itemize} + \item Keretezési módszert (egyértelmű kerethatárok) + \item Kapcsolatvezérlő protokollt (a vonalak felélesztésére, tesztelésére, az opció egyeztetésére és a vonalak elengedésére.) + \item Olyan módot a hálózati réteg-opciók megbeszélésére, amely független az alkalmazott hálózati réteg-protokolltól. + \end{itemize} + Bájt alapú keretszerkezet használ (azaz a legkisebb adategység a bájt). + Vezérlő mező alapértéke a számozatlan keretet jelzi. Protokoll mezőben protokoll kód lehet az LCP, NCP, IP, IPX, AppleTalkvagy más protokollhoz. + \begin{figure}[H] + \centering + \includegraphics[width=0.8\textwidth]{img/ppp_keret.png} + \caption{PPP keret felépítése} + \end{figure} + \end{itemize} + \item[MAC - Media Access Control] \hfill \\ + Eddigi tárgyalásaink során pont-pont összeköttetést feltételeztünk. Most az adatszóró csatornát használó hálózatok tárgykörével foglalkozunk majd. A csatorna kiosztás történhet statikus vagy dinamikus módon. + + Statikus esetben vagy Frekvenciaosztásos nyalábolást vagy időosztásos nyalábolást használnak. Frekvenciaosztásos esetben a sávszélességet osztják $N$ részre, és mindegyik felhasználó egy sávot kap. Időosztásos esetben az időegységet osztják $N$ részre és ezeket adják a felhasználóknak. Mind a két módszer löketszerű forgalom esetén nem tud hatékony lenni. + + A továbbiakban a dinamikus csatorna kiosztási módszereket vizsgáljuk. + \begin{itemize} + \item Verseny protokollok \\ + N független állomás van, amelyeken egy program vagy egy felhasználó továbbítandó kereteket generál. Ha egy állomás generált egy keretet, akkor blokkolt állapotban marad mindaddig, amíg a keretet sikeresen nem továbbította. Egyetlen csatorna van, melyen mindenféle kommunikáció zajlik. Minden állomás tud adatot küldeni és fogadni ezen a csatornán. Ha két keret egy időben kerül átvitelre, akkor átlapolódnak, és az eredményül kapott jel értelmezhetetlenné válik. Ezt nevezzük ütközésnek. Ez minden állomás számára felismerhető. Az ütközésben érintett kereteket később újra kell küldeni. (Ezen a hibán kívül egyéb hiba nem történhet.) + + Kétféle időmodellt különböztetünk meg: + \begin{enumerate} + \item Folytonos – Mindegyik állomás tetszőleges időpontban megkezdheti a küldésre kész keretének sugárzását. + \item Diszkrét – Az időt diszkrét résekre osztjuk. Keret továbbítás csak időrés elején lehetséges. Az időrés lehet üres, sikeres vagy ütközéses + \end{enumerate} + + Az egyes állomások vagy rendelkeznek vivőjel érzékeléssel vagy nem. Ha nem, akkor az állomások nem tudják megvizsgálni a közös csatorna állapotát, ezért egyszerűen elkezdenek küldeni, ha van rá lehetőségük. Ha igen, akkor az állomások meg tudják vizsgálni a közös csatorna állapotát a küldés előtt. A csatorna lehet: foglalt vagy szabad. Ha a foglalt a csatorna, akkor nem próbálják használni az állomások, amíg fel nem szabadul + + \begin{itemize} + \item Egyszerű ALOHA \\ + A felhasználó akkor vihet át adatot, amikor csak szeretne. Ütközés esetén véletlen ideig várakozik az állomás, majd újra próbálkozik. + + Keret idő–egy szabványos, fix hosszúságú keret átviteléhez szükséges idő + + Egy keret akkor nem szenved ütközést, ha elküldésének első pillanatától kezdve egy keretideig nem próbálkozik más állomás keretküldéssel. + + \begin{figure}[H] + \centering + \includegraphics[width=0.6\textwidth]{img/egyszeru_aloha.png} + \caption{Egyszerű ALOHA keret ütközések} + \end{figure} + \item Réselt ALOHA \\ + Az idő diszkrét, keretidőhöz igazodó időszeletek-re osztásával az ALOHA rendszer kapacitása megduplázható. A csatorna terhelésének kis növekedése is drasztikusan csökkentheti a médium teljesítményét. + \item 1-prezisztens CSMA \\ + Vivőjel érzékelés van, azaz minden állomás belehallgathat a csatornába. Folytonos időmodellt használ a protokoll. + + Algoritmus: + \begin{enumerate} + \item Keret leadása előtt belehallgat a csatornába: + \begin{enumerate} + \item Ha foglalt, akkor addig vár, amíg fel nem szabadul. Szabad csatorna esetén azonnal küld. (perzisztens) + \item Ha szabad, akkor küld. + \end{enumerate} + \item Ha ütközés történik, akkor az állomás véletlen hosszú ideig vár, majd újrakezdi a keret leadását. + \end{enumerate} + \item Nem-prezisztens CSMA \\ + Vivőjel érzékelés van, azaz minden állomás belehallgathat a csatornába. Folytonos időmodellt használ a protokoll. Mohóságot kerüli, azaz nem küld azonnal, ha foglalt. + + Algoritmus: + \begin{enumerate} + \item Keret leadása előtt belehallgat a csatornába: + \begin{enumerate} + \item Ha foglalt, akkor véletlen ideig vár (nem figyeli a forgalmat), majd kezdi előröl a küldési algoritmust. (nem-perzisztens) + \item Ha szabad, akkor küld. + \end{enumerate} + \item Ha ütközés történik, akkor az állomás véletlen hosszú ideig vár, majd újrakezdi a keret leadását. + \end{enumerate} + \item p-prezisztens CSMA \\ + Vivőjel érzékelés van, azaz minden állomás belehallgathat a csatornába. Diszkrét időmodellt használ a protokoll. + + Algoritmus: + \begin{enumerate} + \item Adás kész állapotban az állomás belehallgat a csatornába: + \begin{enumerate} + \item Ha foglalt, akkor vár a következő időrésig, majd megismétli az algoritmust. + \item Ha szabad, akkor $p$ valószínűséggel küld, illetve $1-p$ valószínűséggel visszalép a szándékától a következő időrésig. Várakozás esetén a következő időrésben megismétli az algoritmust. Ez addig folytatódik, amíg el nem küldi a keretet, vagy amíg egy másik állomás el nem kezd küldeni, mert ilyenkor úgy viselkedik, mintha ütközés történt volna. + \end{enumerate} + \item Ha ütközés történik, akkor az állomás véletlen hosszú ideig vár, majd újrakezdi a keret leadását. + \end{enumerate} + \item CSMA/CD \\ + Ütközés érzékelés esetén meg lehessen szakítani az adást. Minden állomás küldés közben megfigyeli a csatornát, ha ütközést tapasztalna, akkor megszakítja az adást, és véletlen ideig várakozik, majd újra elkezdi leadni a keretét + \end{itemize} + \begin{figure}[H] + \centering + \includegraphics[width=0.7\textwidth]{img/aloha_csma.jpg} + \caption{ALOHA és CSMA protokollok összehasonlítása} + \end{figure} + \item Verseny mentes protokollok \\ + Motiváció: Az ütközések hátrányosan hatnak a rendszer teljesítményére, és a CSMA/CD nem mindenhol alkalmazható. + + N állomás van. Az állomások 0-ától N-ig egyértelműen sorszámozva vannak. Réselt időmodellt feltételezünk. + \begin{itemize} + \item Egy helyfoglalásos protokoll \\ + Ha az i-edikállomás küldeni szeretne, akkor a i-edikversengési időrésben egy 1-es bit elküldésével jelezheti. Így a versengési időszak végére minden állomás ismeri a küldőket. A küldés a sorszámok szerinti sorrendben történik meg. + \item Bináris visszaszámlálás protokoll \\ + Minden állomás azonos hosszú bináris azonosítóval rendelkezik. A forgalmazni kívánó állomás elkezdi a bináris címét bitenként elküldeni a legnagyobb helyi értékű bittel kezdve. Az azonos pozíciójú bitek logikai VAGY kapcsolatba lépnek ütközés esetén. Ha az állomás nullát küld, de egyet hall vissza, akkor feladja a küldési szándékát, mert van nála nagyobb azonosítóval rendelkező küldő. + \end{itemize} + \item Korlátozott verseny protokollok \\ + Olyan protokoll, amely kis terhelés esetén versenyhelyzetes technikát használ a kis késleltetés érdekében, illetve nagy terhelés mellett ütközésmentes technikát alkalmaz a csatorna jó kihasználása érdekében. + \begin{itemize} + \item Adaptív fabejárás \\ + Minden állomást egy egyértelmű, bináris ID reprezentál. Az ID-k egy (bináris) fa leveleinek felelnek meg. Az időrések a fa egyes csomópontjaihoz vannak rendelve Minden időrésben megvizsgáljuk az adott csomópont alatti részfát. A fa egy $u$ csomópontjánál 3 esetet + különböztethetünk meg: + \begin{itemize} + \item Egy állomás sem küld az $u$ részfában. + \item Pontosan egy állomás küld az $u$ részfában. + \item Több állomás küld az $u$ részfában. Ezt nevezzük kollíziónak. + \end{itemize} + Kollízió esetén hajtsuk végre az ellenőrzést $u$ bal, és jobb oldali gyerekére egyaránt. + + Ezzel a módszerrel könnyen megállapítható, hogy melyik állomás küldhet az adott időszeletben. + \begin{figure}[H] + \centering + \includegraphics[width=0.5\textwidth]{img/adaptivfa.png} + \caption{Adaptív fabejárás protokoll bináris fája} + \end{figure} + \end{itemize} + \end{itemize} + \end{description} +\end{description} +\section{Hálózati réteg} +\begin{description} + \item[Definíció] \hfill \\ + A hálózati réteg fő feladata a csomagok továbbítása a forrás és a cél között. Ez a legalacsonyabb olyan réteg, amely két végpont közötti átvitellel foglalkozik. Ismernie kell a kommunikációs alhálózat topológiáját. Ügyelni kell, hogy ne terheljen túl se bizonyos kommunikációs útvonalakat, se bizonyos routereket úgy, hogy mások tétlen maradnak. + + A szállítási réteg felé nyújtott szolgálatok: + \begin{itemize} + \item Függetlenek az alhálózatok kialakításától + \item Eltakarják a jelen lévő alhálózatok számát, típusát és topológiáját + \item A szállítási réteg számára rendelkezésre bocsájtott hálózati címek egységes számozási rendszert kell alkotnak + \end{itemize} + \item[Forgalom irányítás típusai] \hfill + \begin{itemize} + \item Hierarchikus forgalomirányítás\\ + Routhereket tartományokra osztjuk. A saját tartományát az összes router ismeri, de a többi belső szerkezetéről nincs tudomása. Nagy hálózatok esetén többszintű hierarchia lehet szükséges. + \item Adatszóró forgalomirányítás\\ + egy csomag mindenhová történő egyidejű küldése. + \item Többküldéses forgalomirányítás\\ + Egy csomag meghatározott csoporthoz történő egyidejű küldése. + + \end{itemize} + + \item[Forgalom irányító algoritmusok] \hfill \\ + A hálózati réteg szoftverének azon része, amely azért a döntésért felelős, hogy a bejövő csomag melyik kimeneti vonalon kerüljön továbbításra. A folyamat két lépésre bontható: + \begin{enumerate} + \item Forgalomirányító táblázatok feltöltése és karbantartása. + \item Továbbítás + \end{enumerate} + + A forgalomirányító algoritmusok osztályai: + \begin{enumerate} + \item Adaptív algoritmusok + \begin{enumerate} + \item távolság alapú + \item kapcsolat alapú + \end{enumerate} + A topológia és rendszerint a forgalom is befolyásolhatja a döntést. + \item Nem-adaptív algoritmusok \\ + Offline meghatározás, betöltés a router-ekbe induláskor + \end{enumerate} + + \begin{description} + \item[Dijkstra algoritmus] \hfill \\ + A Dijkstra algoritmus egy statikus algoritmus, melynek célja két csomópont közötti legrövidebb út meghatározása. + + Minden csomópontot felcímkézünk a kezdőpontból az addig megtalált legrövidebb út hosszával. Az algoritmus működése során a címkék változhatnak az utak megtalálásával. Két fajta címkét különböztetünk meg: ideiglenes és állandó. Kezdetben minden címke ideiglenes. A legrövidebb út megtalálásakor a címke állandó címkévé válik, és továbbá nem változik. + \item[Elárasztás algoritmus] \hfill \\ + Elárasztás algoritmusa egy statikus algoritmus. + + Minden bejövő csomagot minden kimenő vonalon továbbítunk kivéve azon, amin érkezett. Így azonban nagyon sok duplikátum keletkezne. Ezért + \begin{itemize} + \item Ugrásszámlálót vezetünk be, melyet minden állomás eggyel csökkent. Ha 0-ra csönnen, eldobják. + \item Az állomások nyilvántartják a már kiküldött csomagokat. Így egy csomagot nem küldenek ki többször. + \end{itemize} + \item[Elosztott Bellman-Ford algoritmus] \hfill \\ + Az Elosztott Bellman-Ford algoritmus adaptív, távolság alapú forgalomirányító algoritmus. Minden csomópont csak a közvetlen szomszédjaival kommunikálhat. Minden állomásnak van saját távolság vektora. Ezt periodikusan elküldi a direkt szomszédoknak. Minden router ismeri a közvetlen szomszédjaihoz a költséget. A kapott távolság vektorok alapján minden csomópont aktualizálja a saját vektorát. + \item[Kapcsolatállapot alapú forgalomirányítás] \hfill \\ + A kapcsolatállapot alapú forgalomirányító algoritmusnak a motivációja, hogy a távolság alapú algoritmusok lassan konvergáltak, illetve az eltérő sávszélek figyelembevétele. \\ + A kapcsolatállapot alapú forgalomirányító algoritmus lépései: + \begin{enumerate} + \item Szomszédok felkutatása, és hálózati címeik meghatározása + \item Megmérni a késleltetést vagy költséget minden szomszédhoz + \item Egy csomag összeállítása a megismert információkból + \item Csomag elküldése az összes többi router-nek + \item Kiszámítani a legrövidebb utat az összes többi router-hez. + \end{enumerate} + \end{description} + \item[Hálózat réteg az Interneten] \hfill \\ + A hálózati réteg szintjén az internet autonóm rendszerek összekapcsolt együttesének tekinthető. Nincs igazi szerkezete, de számos főbb gerinchálózata létezik. A gerinchálózatokhoz csatlakoznak a területi illetve regionális hálózatok. A regionális és területi hálózatokhoz csatlakoznak az egyetemeken, vállalatoknál és az internet szolgáltatóknál lévő LAN-ok. + + Az internet protokollja, az IP. + + Az Interneten a kommunikáció az alábbi módon működik: + \begin{enumerate} + \item A szállítási réteg viszi az adatfolyamokat és datagramokra tördeli azokat. + \item Minden datagram átvitelre kerül az Interneten, esetleg menet közben kisebb egységekre darabolva. + \item A célgép hálózati rétege összeállítja az eredeti datagramot, majd átadja a szállítási rétegének. + \item A célgép szállítási rétege beilleszti a datagramot a vételi folyamat bemeneti adatfolyamába. + \end{enumerate} + + Internet Protokoll - IP + \begin{itemize} + \item Az IP fejrésze: + \begin{itemize} + \item verzió:\\ + IP melyik verzióját használja + \item IHL: \\ + a fejléc hosszát határozza meg + \item szolgálat típusa: \\ + szolgálati osztályt jelöl + \item teljes hossz: \\ + fejléc és adatrész együttes hossza bájtokban + \item azonosítás: \\ + egy datagram minden darabja ugyanazt az azonosításértéket hordozza. + \item DF: \\ + "ne darabold" flag a router-eknek + \item MF: \\ + "több darab" flag minden darabban be kell legyen állítva, kivéve az utolsót. + \item darabeltolás: \\ + a darab helyét mutatja a datagramon belül. + \item élettartam: \\ + másodpercenként kellene csökkenteni a mező értékét, minden ugrásnál csökkentik eggyel az értékét + \item protokoll: \\ + szállítási réteg protokolljának azonosítóját tartalmazza + \item ellenőrző összeg: \\ + a router-eken belüli rossz memóriaszavak által előállított hibák kezelésére használt ellenőrző összeg a fejrészre, amelyet minden ugrásnál újra kell számolni + \item forrás cím és cél cím: \\ + IP cím + \item opciók: \\ + következő verzió bővíthetősége miatt hagyták benne. + \end{itemize} + + \begin{figure}[H] + \centering + \includegraphics[width=0.8\textwidth]{img/ip_fejresz.png} + \caption{IPv4 fejléce} + \end{figure} + + \item IP cím \\ + Minden hoszt és minden router az Interneten rendelkezik egy IP-címmel, amely a hálózat számát és a hoszt számát kódolja. 4 bájton ábrázolják az IP-címet. Az IP-t pontokkal elválasztott decimális rendszerben írják. (Például: 192.168.0.1) Van pár speciális cím (ábra \ref{fig:ip_spec_cimek}). + + \begin{figure}[H] + \centering + \includegraphics[width=0.8\textwidth]{img/ip_spec_cimek.png} + \caption{Speciális IP címek} + \label{fig:ip_spec_cimek} + \end{figure} + + Alhálózatok:\\ + Az azonos hálózatban lévő hosztok ugyanazzal a hálózatszámmal rendelkeznek. Egy hálózat belső felhasználás szempontjából több részre osztódhat, de a külvilág számára egyetlen hálózatként jelenik meg. Azonosításnál az alhálózati maszk ismerete kell a routernek. A forgalomirányító táblázatba a router-eknél (hálózat,0) és (saját hálózat, hoszt) alakú bejegyzések. Ha nincs találat, akkor az alapértelmezett router felé továbbítják a csomagot.\\ + + IP címek fogyása:\\ + Az IP címek gyorsan fogytak. Megoldás: osztályok nélküli környezetek közötti forgalomirányítás (CIDR). A forgalomirányítás megbonyolódik: Minden bejegyzés egy 32-bites maszkkal egészül ki. Egy bejegyzés innentől egy hármassal jellemezhető: (ip-cím, alhálózati maszk, kimeneti vonal). Új csomag esetén a cél címből kimaszkolják az alhálózati címet, és találat esetén a leghosszabb illeszkedés felé továbbítják. + + Másik módszer a NAT, ami gyors javítás az IP címek elfogyásának problémájára. Az internet forgalomhoz minden cégnek egy vagy legalábbis kevés IP-címet adnak, míg vállalaton belül minden számítógéphez egyedi IP-címet használnak a belső forgalomirányításra: \\ + 10.0.0.0 – 10.255.255.255 : 16 777 216 egyedi cím\\ + 172.16.0.0 – 172.31.255.255 : 1 048 576 egyedi cím\\ + 192.168.0.0 – 192.168.255.255 : 65 536 egyedi cím\\ + + IPv6:\\ + Az IPv4-gyel szemben 16 bájt hosszú címeket használ; 8 darab, egyenként négy-négy hexadecimális számjegyből álló csoportként írjuk le. (Például: 8000:0000:0000:0000:0123:4567:89AB:CDEF) Az IP fejléc egyszerűsödött, amely lehetővé teszi a router-eknek a gyorsabb feldolgozást. A biztonság irányába jelentős lépés történt. + + \begin{figure}[H] + \centering + \includegraphics[width=0.8\textwidth]{img/ipv6.png} + \caption{IPv6 fejléce} + \end{figure} + + + \end{itemize} + \item[Protokollok] \hfill + \begin{itemize} + \item Internet Control Message Protocol - ICMP \\ + Feladata a váratlan események jelentése. Többféle ICMP-üzenetet definiáltak: + \begin{itemize} + \item Elérhetetlen cél + \item Időtúllépés + \item Paraméterprobléma + \item Forráslefojtás + \item Visszhang kérés + \item Visszhang válasz + \item etc. + \end{itemize} + \item Address Resolution Protocol - ARP \\ + Feladata az IP cím megfeleltetése egy fizikai címnek. Egy "Kié a 192.60.34.12-es IP-cím?" csomagot küld ki az Ethernet-re adatszórással az alhálózaton. Minden egyes host ellenőrzi,hogy övé-e a kérdéses IP-cím. Ha egyezik az IP a hoszt saját IP-jével, akkor a saját Ethernet címével válaszol. + \item Reverse Address Resolution Protocol - RARP \\ + Feladatat a fizikai cím megfeleltetése egy IP címnek. Az újonnan indított állomás adatszórással csomagot küld ki az Ethernetre: "A 48-bites Ethernet-címem 14.04.05.18.01.25. Tudja valaki az IP címemet?" Az RARP-szerver pedig válaszol a megfelelő IP címmel, mikor meglátja a kérést. + \item Open Shortest Path First - OSPF \\ + Az OSPF az AS-eken (Autonomus System) belüli forgalomirányításért felel. A hálózat topológiáját térképezi fel, és érzékeli a változásokat. A topológiát egy súlyozott irányított gráffal reprezentálja, melyben legolcsóbb utakat keres. + \item Border Gateway Protocol - BGP \\ + Feladata hogy a politikai szempontok szerepet játsszanak az AS-ek közötti forgalomirányítási döntésekben (Pl. Az IBM-nél kezdődő illetve végződő forgalom ne menjen át a Microsoft-on vagy Csak akkor haladjunk át Albánián, ha nincs más út a célhoz.)\\ + A BGP router szempontjából a világ AS-ekből és a közöttük átmenő vonalakból áll. (Két AS összekötött, ha van köztük a BGP-router-eiket összekötő vonal.) + Az átmenő forgalom szempontjából 3 féle hálózat van: + \begin{itemize} + \item Csonka hálózatok, amelyeknek csak egyetlen összeköttetésük van a BGP gráffal + \item Többszörösen bekötött hálózatok, amelyeket használhatna az átmenő forgalom, de ezek ezt megtagadják + \item Tranzit hálózatok, amelyek némi megkötéssel, illetve általában fizetség ellenében, készek kezelni harmadik fél csomagjait + \end{itemize} + \end{itemize} +\end{description} +\section{Szállítói réteg} +\begin{description} + \item[Definíció] \hfill \\ + A szállítási réteg biztosítja, hogy a felhasználók közötti adatátvitel transzparens (átlátszó) legyen. A réteg biztosítja, és ellenőrzi egy adott kapcsolat megbízhatóságát. Az alkalmazási rétegtől kapott adat elejére egy úgynevezett fejlécet csatol, mely jelzi, hogy melyik szállítási rétegbeli protokollal küldik az adatot. Néhány protokoll kapcsolat orientált. Ez azt jelenti, hogy a réteg nyomon követi az adatcsomagokat, és hiba esetén gondoskodik a csomag vagy csomagok újraküldéséről. + + \item[Kapcsolat nélküli és kapcsolatorientált] \hfill \\ + A kapcsolatorientált protokoll elfedi az alkalmazások előtt az átvitel esetleges hibáit, nem kell törődnünk az elveszett, vagy duplán megérkezett, illetve sérült csomagokkal, és azzal sem, hogy milyen sorrendben érkeztek meg. Viszont ez rontja a teljesítményét. + + Kapcsolat nélküli esetben nincs szükség az adat keretekre bontására, és nincs csomagújraküldés. + \item[Megbízhatóság] \hfill \\ + A megbízhatóság ismérvei: + \begin{itemize} + \item Minden csomag megérkezése nyugtázásra kerül. + \item A nem nyugtázott adatcsomagokat újraküldik. + \item A fejléchez és a csomaghoz ellenőrzőösszeg van rendelve. + \item A csomagokat számozza, és a fogadónál sorba rendezésre kerülnek a csomagok a sorszámaik alapján. + \item Duplikátumokat törli. + \end{itemize} + \item[Torlódásfelügyelet] \hfill \\ + Minden hálózaton korlátos az átviteli sávszélessége. Ha több adatot vezetünk a hálózatba, akkor az torlódáshoz (congestion) vezet, vagy akár a hálózat összeomlásához (congestive collapse). Következmény: Az adatcsomagok nem érkeznek meg. + + Lavina jelenség: \\ + A hálózat túlterhelése csomagok elvesztését okozza, ami csomag újraküldését eredményezi. Az újraküldés tovább növeli a hálózat terhelését így még nagyobb lesz csomagvesztés. Ez még több újraküldött csomagot eredményez. ... \\ + A torlódás felügyelet feladata a lavina jelenség elkerülése. + + Követelmények a torlódásfelügyelettel szemben: + \begin{itemize} + \item Hatékonyság: \\ + Az átvitel nagy, míg a késés kicsi. + \item Fairness: \\ + Minden folyamat megközelítőleg azonos részt kap a sávszélességből. (Priorizálás lehetősége fennáll) + \end{itemize} + + A torlódásfelügyelet eszközei: + \begin{itemize} + \item Kapacitásnövelés + \item Erőforrás foglalás és hozzáférés szabályzás + \item Terhelés csökkentése és szabályzása + \end{itemize} + + Stratégiák: + \begin{itemize} + \item Csúszóablak \\ + Adatráta szabályozása ablak segítségével. A fogadó határozza meg az ablak (wnd) méretét. Ha a fogadási puffere tele van, lecsökkenti 0-ra, egyébként \textgreater0-t küld. A küldő nem küld több csomagot, ha az elküldött még nem nyugtázott csomagok száma elérte az ablak méretét. + \begin{figure}[H] + \centering + \includegraphics[width=0.6\textwidth]{img/csuszoablak.png} + \caption{Csúszóablak} + \end{figure} + \item Slow-start \\ + A küldőnek nem szabad a fogadó által küldött ablakméretet azonnal kihasználni. Meghatároz egy másik ablakot (cwnd - Congestion Window), melyet ő választ. Ezután végül amiben küld: min\{wnd, cwnd\}. Kezdetben cwnd = MSS (Maximum Segment Size). Minden csomagnál a megkapott nyugta után növeli: cwnd = cwnd + MSS (azaz minden RTT után duplázódik). Ez addig megy, míg a nyugta egyszer kimarad. + \item TCP-Nagle \\ + Biztosítani kell, hogy a kis csomagok időben egymáshoz közel kerüljenek kiszállításkor, illetve hogy sok adat esetén a nagy csomagok részesüljenek előnyben. \\ + Ehhez: A kis csomagok nem kerülnek kiküldésre, míg nyugták hiányoznak (egy csomag kicsi, ha az adathossz \textless MSS). Ha a korábban küldött csomag nyugtája megérkezik, küldi a következőt. + \item TCP Tahoe és Reno + A TCP csúszóablakot és a Slow-start mechanizmusát is használja. Habár a kezdő ráta kicsi, az ablak mérete rohamosan nő. Amikor a cwnd eléri az ssthresh (slow start threshold) értéket átvált torlódás elkerülési állapotba. A TCP Tahoe és Reno torlódás elkerülési algoritmusok. A két algoritmus abban különbözik, hogy hogyan detektálják és kezelik a csomag vesztést. \\ + \underline{TCP Tahoe}: A torlódás detektálására egy időzítőt állít a várt nyugta megérkezésére. + \begin{itemize} + \item Kapcsolatfelvételkor: cwnd = MSS, ssthresh = $2^{16}$ + \item Csomagvesztésnél : Multiplicative decrease \\ + cwns = MSS, ssthresh = max\{2MSS, $\frac{min\{cwnd, wnd\}}{2}$\} + \item cwnd $\leq $ ssthresh : Slow-start \\ + cwnd = cwnd + MSS + \item cwnd \textgreater ssthresh : Additive Increase \\ + cwnd = cwnd + MSS$frac{MSS}{cwnd}$ + \end{itemize} + \underline{TCP Reno}: A torlódás detektálásához időzítőt és gyors újraadást is használ. [Gyors újraadás: ugyanazon csomaghoz 3 nyugta duplikátum érkezik (4 azonos nyugta), akkor újraküldi a csomagot és Slow-start fázisba lép.] \\ + Gyors újraadás után: ssthresh = max\{$\frac{min\{wnd,cwnd\}}{2}$, 2MSS\}, cwnd = sstresh + 3MSS. \\ + Gyors visszaállítás a gyors újraadás után minden további nyugta után növeli a rátát : cwnd = cwnd + MSS. + \end{itemize} + + Hatékonyság és Fairness: \\ + Az átvitel maximális, ha a terhelés a hálózat kapacitását majdnem eléri. Ha a terhelés tovább nő, túlcsordulnak a pufferek, csomagok vesznek el, újra kell küldeni, drasztikusan nő a válaszidő. Ezt a torlódásnak nevezzük. Ezért a maximális terhelés helyett, ajánlatos a hálózat terhelését a könyök közelében beállítani. Itt a válaszidő csak lassan emelkedik, míg az adatátvitel már a maximum közelében van + + Egy jó torlódáselkerülési (angolul congestion avoidance) stratégia a hálózat terhelését a könyök közelében tartja: \textit{hatékonyság}. Emellett fontos, hogy minden résztvevőt egyforma rátával szolgáljunk ki: \textit{fairness} + + Jelölje az $i$-edik résztvevő adatrátáját a $t$ időpontban $x_i(t)$. + Minden résztvevő aktualizálja az adatrátáját a $t+1$-ik fordulóban: + \begin{align*} + x_i(t+1) = f_0(t) \quad ha \ \sum_{i=1}^{n}x_i(t) \leq K \\ + x_i(t+1) = f_1(t) \quad ha \ \sum_{i=1}^{n}x_i(t) > K + \end{align*} + ahol $f_0(x) = a_I + b_Ix$ a növelési, $f_1(x) = a_D + b_Dx$ a csökkentési stratégia. + + Speciálsi esetek: + \begin{itemize} + \item \textbf{M}ultiplcative \textbf{I}ncrease \textbf{M}ultiplcative \textbf{D}ecrease - MIMD: + \begin{align*} + f_0(x) = b_Ix \quad (b_I > 1) \\ + f_1(x) = b_Dx \quad (b_D < 1) + \end{align*} + \item \textbf{A}dditive \textbf{I}ncrease \textbf{A}dditive \textbf{D}ecrease - AIAD: + \begin{align*} + f_0(x) = a_I+x \quad (a_I > 0) \\ + f_1(x) = a_D+x \quad (a_D < 0) + \end{align*} + \item \textbf{A}dditive \textbf{I}ncrease \textbf{M}ultiplcative \textbf{D}ecrease - AIMD: + \begin{align*} + f_0(x) = a_I+x \quad (a_I > 0) \\ + f_1(x) = b_Dx \quad (b_D < 1) + \end{align*} + \end{itemize} + + \item[Multiplexálás, demultiplexálás] \hfill \\ + Multiplexelés alatt a telekommunikációban azt az eljárást értik, amikor két vagy több csatornát összefognak egy csatornába úgy, hogy az inverz multiplexelés művelettel, vagy demultiplexeléssel, vagy demuxálással elő tudják állítani az eredeti csatornákat. Az eredeti csatornák egy úgynevezett kódolási sémával azonosíthatóak. + \item[Interakciós modellek] \hfill + \begin{itemize} + \item Kétirányú bájtfolyam \\ + Az adatok két egymással ellentétes irányú bájt-sorozatként kerülnek átvitelre. A tartalom nem interpretálódik Az adatcsomagok időbeli viselkedése megváltozhat: átvitel sebessége növekedhet, csökkenhet, más késés, más sorrendben is megérkezhetnek. Megpróbálja az adatcsomagokat időben egymáshoz közel kiszállítani. Megpróbálja az átviteli közeget hatékonyan használni. + + \item RPC \\ + A távoli gépen futtatandó eljárás eléréséhez hálózati kommunikációra van szükség, ezt az eljáráshívási mechanizmust az RPC (Remote Procedure Call) fedi el. + + A hívás lépései: + \begin{enumerate} + \item A kliensfolyamat lokálisan meghívja a + klienscsonkot. + \item Az becsomagolja az eljárás azonosítóját + és paramétereit, meghívja az OS-t. + \item Az átküldi az üzenetet a távoli OS-nek. + \item Az átadja az üzenetet a + szervercsonknak. + \item Az kicsomagolja a paramétereket, + átadja a szervernek. + \item A szerver lokálisan meghívja az eljárást, + megkapja a visszatérési értéket. + \item Ennek visszaküldése a klienshez + hasonlóan zajlik, fordított irányban. + \end{enumerate} + \begin{figure}[H] + \centering + \includegraphics[width=0.6\textwidth]{img/rpc.png} + \caption{RPC} + \end{figure} + \end{itemize} + \item[Protokollok] \hfill + \begin{itemize} + \item TCP + \begin{itemize} + \item Megbízható adatfolyam létrehozása két végpont között + \item Az alkalmazási réteg adatáramát osztja csomagokra + \item A másik végpont a csomagok fogadásról nyugtát küld + \end{itemize} + A TCP fejléc tartalma: + \begin{itemize} + \item küldő port(16 bit)\\ + A küldő folyamatot azonosítja + \item cél port(16 bit)\\ + A címzett folyamat azonosítója + \item sorszám(32 bit)\\ + Az első adatbájt sorszáma az aktuális szegmensen belül. Ha a SYN jelzőbit értéke 1, akkor ez a sorszám a kezdeti sorszám, azaz az első adatbájt sorszáma a kezdeti sorszám + 1 lesz. + \item nyugtaszám(32 bit)\\ + Ha az ACK jelzőbit értéke 1, akkor a fogadó által következőnek fogadni kívánt sorszámot tartalmazza. Minden kapcsolat felépítés esetén elküldésre kerül. + \item fejléc hossza (4 bit)\\ + A TCP fejléc hossza 32-bites egységekben. + \item Ablak(16 bit)\\ + A nyugtázott bájttal kezdődően hány bájtot lehet elküldeni. (A 0 érték is érvényes.) + \item Ellenőrzőösszeg(16 bit)\\ + Az adat-, fej-, és pszeudofejrész ellenőrzésére. + \item Opciók(0-40 bájt)\\ + A szabványos fejlécen kívüli lehetőségekre tervezték. Legfontosabb ilyen lehetőség az MSS, azaz a legnagyobb szegmens méret megadása. További opciók: MD5-aláírás, TCP-AO, "usertimeout", stb. + \item sürgősségi mutató(16 bit) \\ + A sürgős adat bájtban mért helyét jelzi a jelenlegi bájtsorszámhoz viszonyítva. + \item Jelző bitek (6) + \begin{enumerate} + \item URG – Sürgős jelzőbit. + \item ACK – nyugta jelzés. + \item PSH – Az jelzi, hogy gyors adattovábbítás kell a felhasználói rétegnek. + \item RST – Kapcsolat egyoldalú bontását jelzi. + \item SYN – Sorszám szinkronizációtjelez. + \item FIN – Adatfolyam végét jelzi. + \end{enumerate} + \end{itemize} + \begin{figure}[H] + \centering + \includegraphics[width=0.8\textwidth]{img/tcp_fejlec.png} + \caption{TCP Fejléc} + \end{figure} + TCP jellemzői: + \begin{itemize} + \item Kapcsolatorientált + \item Megbízható + \item Kétirányú bájtfolyam + \end{itemize} + \item UDP + \begin{itemize} + \item Egyszerű, nem megbízható szolgáltatás csomagok küldésére + \item Az alkalmazási réteg határozza meg a csomag méretét + \item Az inputot egy datagrammá alakítja + \end{itemize} + Összeköttetés nélküli protokoll. Olyan szegmenseket használ az átvitelhez, amelyek egy 8 bájtos fejrészből, valamint a felhasználói adatokból állnak.\\ + A Fejrész tartalmaz: + \begin{itemize} + \item egy forrásportot(2 bájt); + \item egy célportot(2 bájt); + \item egy UDP szegmens hossz értéket (2 bájt); + \item egy UDP ellenőrzőösszeget (2 bájt) + \end{itemize} + Az UDP nem végez forgalomszabályozást, hibakezelést vagy újraküldést egy rossz szegmens fogadása után. Kliens-szerver alkalmazások esetén kifejezetten hasznos lehet az UDP a rövid üzenetek miatt. + \end{itemize} +\end{description} + +\section{Alkalmazási réteg} +\begin{description} + \item[DNS] \hfill \\ + A Domain Name System (DNS), azaz a tartománynévrendszer egy hierarchikus, nagymértékben elosztott elnevezési rendszer számítógépek, szolgáltatások, illetve az internetre vagy egy magánhálózatra kötött bármilyen erőforrás számára. A részt vevő entitások számára kiosztott tartománynevekhez (doménekhez) különböző információkat társít. Legfontosabb funkciójaként az emberek számára értelmes tartományneveket a hálózati eszközök számára érthető numerikus azonosítókká ``fordítja le'', ``oldja fel'', melyek segítségével ezeket az eszközöket meg lehet találni, meg lehet címezni a hálózaton. + Gyakran használt analógia a tartománynévrendszer magyarázatához, hogy az internet egyfajta telefonkönyve, amiből ki lehet keresni az emberek számára értelmezhető számítógép-állomásnevekhez tartozó IP-címeket. Például a www.example.com tartománynévhez a 192.0.32.10 (IPv4) és a 2620:0:2d0:200::10 (IPv6) címek tartoznak. + + A DNS lehetővé teszi internetes erőforrások csoportjaihoz nevek hozzárendelését olyan módon, hogy az ne függjön az erőforrások fizikai helyétől. Így a világhálós (WWW) hiperlinkek, internetes kapcsolattartási adatok konzisztensek és állandóak maradhatnak akkor is, ha az internet útválasztási rendszerében változás történik, vagy a részt vevő mobileszközt használ. Az internetes tartománynevek további célja az egyszerűsítés, egy doménnevet (pl. www.example.com) sokkal könnyebb megjegyezni, mint egy IP-címet, mint 208.77.188.166 (IPv4) vagy 2001:db8:1f70::999:de8:7648:6e8 (IPv6). A felhasználók így megjegyezhetik a számukra jelentést hordozó web- (URL) és e-mail-címeket, anélkül, hogy tudnák, a számítógép valójában hogyan éri el ezeket. + + A DNS-ben a doménnevek kiosztásának és az IP-címek hozzárendelésének a felelősségét delegálják; minden tartományhoz mérvadó névkiszolgáló (autoritatív névszerver) tartozik. A mérvadó névkiszolgálók felelősek a saját doménjeikért. Ezt a felelősséget tovább delegálhatják, így az al-doménekért más névkiszolgáló felelhet. Ez a mechanizmus áll a DNS elosztott és hibatűrő működése mögött, és ezért nem szükséges egyetlen központi címtárat fenntartani és állandóan frissíteni. + + A tartománynévrendszerben egyéb információkat is tárolnak, például egy adott internetes tartomány számára e-mailt fogadó levelezőkiszolgálók listáját. Az egész világot behálózó, elosztott, kulcsszó-alapú átirányítási szolgáltatásként a Domain Name System az internet funkcionalitásának alapvető fontosságú eleme. + + RFID tagek, UPC-k, IP-telefonszámok és még sok más egyéb tárolására is használható a DNS adatbázisa. + + A Domain Name System specifikálja az adatbázis technikai képességeit, emellett leírja az internetprotokollcsalád részét képező DNS protokollt, részletesen meghatározza a DNS-ben használt adatstruktúrákat és kommunikációt. + + \item[HTTP] \hfill \\ + A HTTP (HyperText Transfer Protocol) egy információátviteli protokoll elosztott, kollaboratív, hipermédiás, információs rendszerekhez. + + A HTTP fejlesztését a World Wide Web Consortium és az Internet Engineering Task Force koordinálta RFC-k formájában. Az 1999-ben kiadott RFC 2616 definiálja a HTTP/1.1-et, amit 2015 végére leváltott a HTTP/2.0-ás verzió, amit az RFC 7540 definiál. Hivatalosan ez a legújabb protokoll. + + A HTTP egy kérés-válasz alapú protokoll kliens és szerver között. A HTTP-klienseket a ``user agent'' gyűjtőnévvel is szokták illetni. A user agent jellemzően, de nem feltétlenül webböngésző. + + A HTTP a TCP/IP réteg felett helyezkedik el. A HTTP implementálható más megbízható szállítási réteg felett is, akár az interneten, akár más hálózaton. Kizárólagosan TCP protokollt használ, mivel az adatveszteség nem megengedhető. + \item[DHCP] \hfill \\ + A dinamikus állomáskonfiguráló protokoll (angolul Dynamic Host Configuration Protocol, rövidítve DHCP) egy számítógépes hálózati kommunikációs protokoll. + + Ez a protokoll azt oldja meg, hogy a TCP/IP hálózatra csatlakozó hálózati végpontok (például számítógépek) automatikusan megkapják a hálózat használatához szükséges beállításokat. Ilyen szokott lenni például az IP-cím, hálózati maszk, alapértelmezett átjáró stb. + + A DHCP szerver-kliens alapú protokoll, nagy vonalakban a kliensek által küldött DHCP-kérésekből, és a szerver által adott DHCP-válaszokból áll. + + A DHCP-vel dinamikusan oszthatóak ki IP-címek, tehát a hálózatról lecsatlakozó számítógépek IP-címeit megkapják a hálózatra felcsatlakozó számítógépek, ezért hatékonyabban használhatóak ki a szűkebb címtartományok. + + 3 féle IP-kiosztás lehetséges DHCP-vel: + \begin{itemize} + \item kézi (MAC-cím alapján) + \item automatikus (DHCP-vel kiadható IP-tartomány megadásával) + \item dinamikus (IP-tartomány megadásával, de az IP-címek ``újrahasznosításával'') + \end{itemize} + + \item[ARP] \hfill \\ + Az ARP (Address Resolution Protocol, azaz címfeloldási protokoll) az informatikában a számítógépes hálózatokon használatos módszer az IP-címek és fizikai címek egymáshoz rendeléséhez. Gyakorlatilag az IP-cím ismeretében hozzájutunk a 48 bites hálózati kártya gyártója által meghatározott fizikai címhez. Az IPv4 és az Ethernet széles körű elterjedtsége miatt általában IP-címek és Ethernet-címek közötti fordításra használják, de ATM- vagy FDDI-hálózatokban is működőképes. + + Két ügyfélgép a következő négy alapesetben használja az ARP protokollt: + \begin{itemize} + \item Ha a két ügyfélgép ugyanazon a hálózaton található, és az egyik szeretne csomagot küldeni a másik számára. + \item Ha a két ügyfélgép különböző hálózaton található, és átjárón/útválasztón (gateway/router) keresztül érik el egymást. + \item Ha egy útválasztónak tovább kell küldenie egy ügyfél csomagját egy másik útválasztón keresztül. + \item Ha egy útválasztónak tovább kell küldenie egy ügyfél csomagját a címzettnek, ami ugyanazon a hálózaton található. + \end{itemize} + + Az első esetben a két ügyfél ugyanazon a fizikai hálózaton található (tehát közvetlenül kommunikálhatnak egymással útválasztó igénybevétele nélkül). A másik három eset az interneten leggyakoribb, ahol általában bármely két számítógép több mint 3 ugrás (hop) távolságra van egymástól. + + Képzeljük el, hogy az A számítógép küld csomagot a D számítógépnek, és köztük B és C útválasztók találhatók. A 2. esetben A küld B-nek, a 3. esetben B küld C-nek, és a 4. esetben C küld D-nek csomagot. +\end{description} + +\end{document} \ No newline at end of file diff --git a/16.Számítógépes hálózatok és Internet eszközök/img/adaptivfa.png b/18. Számítógépes hálózatok és Internet eszközök/img/adaptivfa.png similarity index 100% rename from 16.Számítógépes hálózatok és Internet eszközök/img/adaptivfa.png rename to 18. Számítógépes hálózatok és Internet eszközök/img/adaptivfa.png diff --git a/16.Számítógépes hálózatok és Internet eszközök/img/alapsav.png b/18. Számítógépes hálózatok és Internet eszközök/img/alapsav.png similarity index 100% rename from 16.Számítógépes hálózatok és Internet eszközök/img/alapsav.png rename to 18. Számítógépes hálózatok és Internet eszközök/img/alapsav.png diff --git a/16.Számítógépes hálózatok és Internet eszközök/img/aloha_csma.jpg b/18. Számítógépes hálózatok és Internet eszközök/img/aloha_csma.jpg similarity index 100% rename from 16.Számítógépes hálózatok és Internet eszközök/img/aloha_csma.jpg rename to 18. Számítógépes hálózatok és Internet eszközök/img/aloha_csma.jpg diff --git a/16.Számítógépes hálózatok és Internet eszközök/img/amplitudo_key.png b/18. Számítógépes hálózatok és Internet eszközök/img/amplitudo_key.png similarity index 100% rename from 16.Számítógépes hálózatok és Internet eszközök/img/amplitudo_key.png rename to 18. Számítógépes hálózatok és Internet eszközök/img/amplitudo_key.png diff --git a/16.Számítógépes hálózatok és Internet eszközök/img/amplitudo_mod.png b/18. Számítógépes hálózatok és Internet eszközök/img/amplitudo_mod.png similarity index 100% rename from 16.Számítógépes hálózatok és Internet eszközök/img/amplitudo_mod.png rename to 18. Számítógépes hálózatok és Internet eszközök/img/amplitudo_mod.png diff --git a/16.Számítógépes hálózatok és Internet eszközök/img/bitbeszuras.png b/18. Számítógépes hálózatok és Internet eszközök/img/bitbeszuras.png similarity index 100% rename from 16.Számítógépes hálózatok és Internet eszközök/img/bitbeszuras.png rename to 18. Számítógépes hálózatok és Internet eszközök/img/bitbeszuras.png diff --git a/16.Számítógépes hálózatok és Internet eszközök/img/csuszoablak.png b/18. Számítógépes hálózatok és Internet eszközök/img/csuszoablak.png similarity index 100% rename from 16.Számítógépes hálózatok és Internet eszközök/img/csuszoablak.png rename to 18. Számítógépes hálózatok és Internet eszközök/img/csuszoablak.png diff --git a/16.Számítógépes hálózatok és Internet eszközök/img/egyszeru_aloha.png b/18. Számítógépes hálózatok és Internet eszközök/img/egyszeru_aloha.png similarity index 100% rename from 16.Számítógépes hálózatok és Internet eszközök/img/egyszeru_aloha.png rename to 18. Számítógépes hálózatok és Internet eszközök/img/egyszeru_aloha.png diff --git a/16.Számítógépes hálózatok és Internet eszközök/img/egyszeru_bithiba.png b/18. Számítógépes hálózatok és Internet eszközök/img/egyszeru_bithiba.png similarity index 100% rename from 16.Számítógépes hálózatok és Internet eszközök/img/egyszeru_bithiba.png rename to 18. Számítógépes hálózatok és Internet eszközök/img/egyszeru_bithiba.png diff --git a/16.Számítógépes hálózatok és Internet eszközök/img/elektromagneses.png b/18. Számítógépes hálózatok és Internet eszközök/img/elektromagneses.png similarity index 100% rename from 16.Számítógépes hálózatok és Internet eszközök/img/elektromagneses.png rename to 18. Számítógépes hálózatok és Internet eszközök/img/elektromagneses.png diff --git a/16.Számítógépes hálózatok és Internet eszközök/img/fazis_key.png b/18. Számítógépes hálózatok és Internet eszközök/img/fazis_key.png similarity index 100% rename from 16.Számítógépes hálózatok és Internet eszközök/img/fazis_key.png rename to 18. Számítógépes hálózatok és Internet eszközök/img/fazis_key.png diff --git a/16.Számítógépes hálózatok és Internet eszközök/img/fazis_mod.png b/18. Számítógépes hálózatok és Internet eszközök/img/fazis_mod.png similarity index 100% rename from 16.Számítógépes hálózatok és Internet eszközök/img/fazis_mod.png rename to 18. Számítógépes hálózatok és Internet eszközök/img/fazis_mod.png diff --git a/16.Számítógépes hálózatok és Internet eszközök/img/frekvencia_key.png b/18. Számítógépes hálózatok és Internet eszközök/img/frekvencia_key.png similarity index 100% rename from 16.Számítógépes hálózatok és Internet eszközök/img/frekvencia_key.png rename to 18. Számítógépes hálózatok és Internet eszközök/img/frekvencia_key.png diff --git a/16.Számítógépes hálózatok és Internet eszközök/img/frekvencia_mod.png b/18. Számítógépes hálózatok és Internet eszközök/img/frekvencia_mod.png similarity index 100% rename from 16.Számítógépes hálózatok és Internet eszközök/img/frekvencia_mod.png rename to 18. Számítógépes hálózatok és Internet eszközök/img/frekvencia_mod.png diff --git a/16.Számítógépes hálózatok és Internet eszközök/img/hamming1.png b/18. Számítógépes hálózatok és Internet eszközök/img/hamming1.png similarity index 100% rename from 16.Számítógépes hálózatok és Internet eszközök/img/hamming1.png rename to 18. Számítógépes hálózatok és Internet eszközök/img/hamming1.png diff --git a/16.Számítógépes hálózatok és Internet eszközök/img/hamming2.png b/18. Számítógépes hálózatok és Internet eszközök/img/hamming2.png similarity index 100% rename from 16.Számítógépes hálózatok és Internet eszközök/img/hamming2.png rename to 18. Számítógépes hálózatok és Internet eszközök/img/hamming2.png diff --git a/16.Számítógépes hálózatok és Internet eszközök/img/hamming3.png b/18. Számítógépes hálózatok és Internet eszközök/img/hamming3.png similarity index 100% rename from 16.Számítógépes hálózatok és Internet eszközök/img/hamming3.png rename to 18. Számítógépes hálózatok és Internet eszközök/img/hamming3.png diff --git a/16.Számítógépes hálózatok és Internet eszközök/img/hdlc_keret.png b/18. Számítógépes hálózatok és Internet eszközök/img/hdlc_keret.png similarity index 100% rename from 16.Számítógépes hálózatok és Internet eszközök/img/hdlc_keret.png rename to 18. Számítógépes hálózatok és Internet eszközök/img/hdlc_keret.png diff --git a/16.Számítógépes hálózatok és Internet eszközök/img/ip_fejresz.png b/18. Számítógépes hálózatok és Internet eszközök/img/ip_fejresz.png similarity index 100% rename from 16.Számítógépes hálózatok és Internet eszközök/img/ip_fejresz.png rename to 18. Számítógépes hálózatok és Internet eszközök/img/ip_fejresz.png diff --git a/16.Számítógépes hálózatok és Internet eszközök/img/ip_spec_cimek.png b/18. Számítógépes hálózatok és Internet eszközök/img/ip_spec_cimek.png similarity index 100% rename from 16.Számítógépes hálózatok és Internet eszközök/img/ip_spec_cimek.png rename to 18. Számítógépes hálózatok és Internet eszközök/img/ip_spec_cimek.png diff --git a/16.Számítógépes hálózatok és Internet eszközök/img/ipv6.png b/18. Számítógépes hálózatok és Internet eszközök/img/ipv6.png similarity index 100% rename from 16.Számítógépes hálózatok és Internet eszközök/img/ipv6.png rename to 18. Számítógépes hálózatok és Internet eszközök/img/ipv6.png diff --git a/16.Számítógépes hálózatok és Internet eszközök/img/karakterbeszuras.png b/18. Számítógépes hálózatok és Internet eszközök/img/karakterbeszuras.png similarity index 100% rename from 16.Számítógépes hálózatok és Internet eszközök/img/karakterbeszuras.png rename to 18. Számítógépes hálózatok és Internet eszközök/img/karakterbeszuras.png diff --git a/16.Számítógépes hálózatok és Internet eszközök/img/karakterszamlalas.png b/18. Számítógépes hálózatok és Internet eszközök/img/karakterszamlalas.png similarity index 100% rename from 16.Számítógépes hálózatok és Internet eszközök/img/karakterszamlalas.png rename to 18. Számítógépes hálózatok és Internet eszközök/img/karakterszamlalas.png diff --git a/16.Számítógépes hálózatok és Internet eszközök/img/paritasbit.png b/18. Számítógépes hálózatok és Internet eszközök/img/paritasbit.png similarity index 100% rename from 16.Számítógépes hálózatok és Internet eszközök/img/paritasbit.png rename to 18. Számítógépes hálózatok és Internet eszközök/img/paritasbit.png diff --git a/16.Számítógépes hálózatok és Internet eszközök/img/ppp_keret.png b/18. Számítógépes hálózatok és Internet eszközök/img/ppp_keret.png similarity index 100% rename from 16.Számítógépes hálózatok és Internet eszközök/img/ppp_keret.png rename to 18. Számítógépes hálózatok és Internet eszközök/img/ppp_keret.png diff --git a/16.Számítógépes hálózatok és Internet eszközök/img/rpc.png b/18. Számítógépes hálózatok és Internet eszközök/img/rpc.png similarity index 100% rename from 16.Számítógépes hálózatok és Internet eszközök/img/rpc.png rename to 18. Számítógépes hálózatok és Internet eszközök/img/rpc.png diff --git a/16.Számítógépes hálózatok és Internet eszközök/img/szelessav.png b/18. Számítógépes hálózatok és Internet eszközök/img/szelessav.png similarity index 100% rename from 16.Számítógépes hálózatok és Internet eszközök/img/szelessav.png rename to 18. Számítógépes hálózatok és Internet eszközök/img/szelessav.png diff --git a/16.Számítógépes hálózatok és Internet eszközök/img/szinkronizacio.png b/18. Számítógépes hálózatok és Internet eszközök/img/szinkronizacio.png similarity index 100% rename from 16.Számítógépes hálózatok és Internet eszközök/img/szinkronizacio.png rename to 18. Számítógépes hálózatok és Internet eszközök/img/szinkronizacio.png diff --git a/16.Számítógépes hálózatok és Internet eszközök/img/tcp_fejlec.png b/18. Számítógépes hálózatok és Internet eszközök/img/tcp_fejlec.png similarity index 100% rename from 16.Számítógépes hálózatok és Internet eszközök/img/tcp_fejlec.png rename to 18. Számítógépes hálózatok és Internet eszközök/img/tcp_fejlec.png diff --git a/19. Osztott rendszerek és konkurens programozás/19. Osztott rendszerek és konkurens programozás.pdf b/19. Osztott rendszerek és konkurens programozás/19. Osztott rendszerek és konkurens programozás.pdf new file mode 100644 index 0000000..191f440 Binary files /dev/null and b/19. Osztott rendszerek és konkurens programozás/19. Osztott rendszerek és konkurens programozás.pdf differ diff --git a/19. Osztott rendszerek és konkurens programozás/19. Osztott rendszerek és konkurens programozás.tex b/19. Osztott rendszerek és konkurens programozás/19. Osztott rendszerek és konkurens programozás.tex new file mode 100644 index 0000000..8a8b12e --- /dev/null +++ b/19. Osztott rendszerek és konkurens programozás/19. Osztott rendszerek és konkurens programozás.tex @@ -0,0 +1,841 @@ +\documentclass[margin=0px]{article} + +\usepackage{listings} +\usepackage[utf8]{inputenc} +\usepackage{graphicx} +\usepackage{float} +\usepackage[a4paper, margin=0.7in]{geometry} +\usepackage{amsthm} +\usepackage{amssymb} +\usepackage{fancyhdr} +\usepackage{setspace} + +\onehalfspacing + +\renewcommand{\figurename}{ábra} + +\newenvironment{tetel}[1]{\paragraph{#1}}{} + +\pagestyle{fancy} +\lhead{\it{PTI BSc Záróvizsga tételek}} +\rhead{19. Osztott rendszerek és konkurens programozás} + +\title{\textbf{{\Large ELTE IK - Programtervező Informatikus BSc} \vspace{0.2cm} \\ {\huge Záróvizsga tételek}} \vspace{0.3cm} \\ 19. Osztott rendszerek és konkurens programozás} +\author{} +\date{} + +\begin{document} +\maketitle + +\begin{tetel}{Osztott rendszerek és konkurens programozás} + \begin{itemize} + \item[] \textbf{A, C}: Folyamat fogalma, elosztott rendszerek tulajdonságai és felépítése, elnevezési rendszerek, kommunikáció, szinkronizáció, konzisztencia. + \item[] \textbf{B}: Feladatok specifikációja biztonsági és haladási feltételekkel, absztrakt párhuzamos program tulajdonságai, megoldás fogalma, nevezetes feladatok megoldása párhuzamos és elosztott programokkal. + \item[] \textbf{2018}: Szálkezelés. Ütemezés, kontextusváltás. Race condition. Szinkronizáció. Blokkoló műveletek. Memória (stack és heap) használata a szálakban. A konkurens programozás nyelvi eszközei. Szinkronizációhoz és kommunikációhoz használható adatszerkezetek. + \end{itemize} +\end{tetel} + +\section{Folyamatok, szálak} + +\noindent \textbf{Szál}: A szál (thread) a processzor egyfajta szoftveres megfelelője, minimális kontextussal. Ha a szálat +megállítjuk, a kontextus elmenthető és továbbfuttatáshoz visszatölthető.\\ + +\noindent \textbf{Folyamat}: A folyamat (process vagy task) egy vagy több szálat összefogó nagyobb egység. Egy folyamat +szálai közös memóriaterületen (címtartományon) dolgoznak, azonban különböző folyamatok nem látják egymás memóriaterületét.\\ + +\noindent \textbf{Kontextusváltás}: A másik folyamatnak/szálnak történő vezérlésátadás, így egy processzor több szálat/ folyamatot +is végre tud hajtani.\\ + +\noindent \textbf{Szál vs. folyamat}: A szálak közötti váltáshoz nem kell igénybe venni az oprendszer szolgáltatásait, míg +a folyamatok közötti váltásnál ahhoz, hogy a régi és új folyamat memóriaterülete elkülönüljön a memóriavezérlő (MMU) +tartalmának jó részét át kell írni, amihez csak a kernel szintnek van joga. A folyamatok létrehozása, törlése és a kontextusváltás +közöttük sokkal költségesebb a szálakénál. + +\section{Elosztott rendszerek tulajdonságai és felépítése} + +\noindent \textbf{Elosztott rendszer fogalma}: Az elosztott rendszer önálló számítógépek olyan összessége, amely kezelői számára +egyetlen koherens rendszernek tűnik. + +\subsection{Az elosztott rendszer céljai, tulajdonságai} + +Az elosztott rendszer céljai a következők: + +\begin{itemize} + \item Távoli erőforrások elérhetővé tétele + + \item Átlátszóság (transparency) + + \item Nyitottság (openness) + + \item Skálázhatóság +\end{itemize} + +\subsubsection{Átlátszóság} + +Az átlátszóság nem más, mint az erőforrásokkal kapcsolatos különböző információk elrejtése a felhasználó elől. +Az alapján, hogy mit rejtünk el, többféle fajtája létezik: + +\begin{figure}[H] + \centering + \includegraphics[width=0.8\linewidth]{img/atlatszosag} + \caption{Az átlátszóság különböző típusai.} + \label{fig:atlatszosag} +\end{figure} + +\subsubsection{Nyitottság} + +A rendszer képes más nyitott rendszerek számára szolgáltatásokat nyújtani, és azok szolgáltatásait igénybe venni: + +\begin{itemize} + \item A rendszerek jól definiált interfészekkel rendelkeznek. + \item Az alkalmazások hordozhatóságát (portability) minél inkább támogatják. + \item Könnyen elérhető a rendszerek együttműködése. +\end{itemize} + +\noindent A nyitott elosztott rendszer legyen könnyen alkalmazható heterogén környezetben, azaz +különböző hardvereken, platformokon, programozási nyelveken.\\ + +\noindent \textbf{Implementálása}: + +\begin{itemize} + \item Fontos, hogy a rendszer könnyen cserélhető elemekből álljon. + \item Belső interfészek használata, nem egyetlen monolitikus rendszer. + \item A rendszernek minél jobban paraméterezhetőnek kell lennie. + \item Egyetlen komponens megváltoztatása/cseréje lehetőleg minél kevésbé + hasson a rendszer más részeire. +\end{itemize} + +\subsubsection{Skálázhatóság} + +Többféle jelentése van, 3 fontos dimenzió: + +\begin{enumerate} + \item méret szerinti skálázhatóság: a felhasználók és/vagy folyamatok száma + \item földrajzi skálázhatóság: a csúcsok közötti legnagyobb távolság + \item adminisztrációs skálázhatóság: az adminisztrációs tartományok száma +\end{enumerate} + +Ezek közül a legtöbb rendszer a méret szerinti skálázhatóságot kezeli, ennek egy lehetséges megvalósítási +módja erősebb szerverek használata. A másik kettőt nehezebb kezelni.\\ + +\noindent Technikák a skálázhatóság megvalósítására: + +\begin{itemize} + \item A kommunikációs késleltetés elfedése azzal, hogy a válaszra várás közben más tevékenységet végzünk. Ehhez + aszinkron kommunikáció szükséges. + + \item Elosztás: az adatokat és számításokat több számítógép tárolja/végzi (pl. amit lehet, a klienssel számoltatunk ki, + elosztott elnevezési rendszerek használata, stb.) + + \item Replikáció/cache-elés: Több számítógép tárolja egy adat másolatait +\end{itemize} + +A skálázhatóságnak ára van. Több másolat fenntartása inkonzisztenciához vezethet (ha módosítjuk az egyiket, az eltérhet a többitől). +Ez globális szinkronizációval kikerülhető (minden egyes változtatás után az összes másolatot frissítjük), viszont a globális +szinkronizáció rosszul skálázódik. Emiatt sok esetben fel kell hagynunk a globális szinkronizációval, ez viszont bizonyos +mértékű inkonzisztenciát eredményez. Rendszerfüggő, hogy ez milyen mértékben megengedett. A cél az, hogy az inkonzisztencia mértéke +a megengedett szint alatt maradjon. + +\subsection{Elosztott rendszerek típusai} + +\noindent \textbf{Főbb típusok}: +\begin{itemize} + \item Elosztott számítási rendszerek: + \item Elosztott információs rendszerek + \item Elosztott átható rendszerek +\end{itemize} + +\subsubsection{Elosztott számítási rendszerek} + +Célja számítások végzése nagy teljesítménnyel.\\ + +\noindent \textbf{Cluster (fürt)}: Lokális hálózatra kapcsolt számítógépek összessége. Homogén rendszer (ugyanaz az oprendszer, +hardveresen hasonlóak), központosított vezérléssel (általában egy gépre).\\ + +\noindent \textbf{Grid (rács)} Nagyméretű hálózatokra is kiterjedhet, akár több szervezeti egységen is átívelhet. Heterogén +architektúra jellemzi.\\ + +\noindent \textbf{Cloud(felhő)}: Többrétegű architektúra: hardver, infrastruktúra, platform, alkalmazás. + +\subsubsection{Elosztott információs rendszerek} + +Az elsődleges cél általában adatok kezelése, illetve más információs rendszerek elérése. Például tranzakciókezelő rendszerek. + +A tranzakció adatok összességén (pl. egy adatbázison, adatbázis objektumon, stb.) végzett művelet (lehetnek részműveletei). +A tranzakciókkal szemben az alábbi követelményeket szokás támasztani (ACID): + +\begin{itemize} + \item Oszthatatlan, elemi (atomicity): Vagy a teljes tranzakció végbemegy minden részműveletével, vagy az + adattárház egyáltalán nem változik. + + \item Konzisztens (consistency): Az adattárra akkor mondjuk, hogy érvényes, ha bizonyos, az adott adattárra + megfogalmazott feltételek teljesülnek. Egy tranzakció konzisztens, ha érvényes állapotot állít elő a tranzakció + végén. + + \item Elkülöníthető, sorosítható (isolation): Egyszerre zajló tranzakciók olyan eredményt adnak, mintha + egymás után hajtódtak volna végre. + + \item Tartósság (durability): Végrehajtás után az eredményt tartós adattárolóra mentjük, így az összeomlás esetén + visszaállítható. +\end{itemize} + + +\subsection{Elosztott rendszerek felépítése} +Alapötlet: A rendszer elemeit szervezzük logikai szerepük szerint különböző komponensekbe, és ezeket osszuk +el a rendszer gépein.\\ + +\subsubsection{Központosított architektúrák} + +\noindent \textbf{Kliens-szerver modell}: Egyes folyamatok (szerverek) szolgáltatásokat ajánlanak, míg más folyamatok (kliensek) +ezeket a szolgáltatásokat szeretnék használni. A kliens kérést küld a szervernek, amire a szerver válaszol, így veszi igénybe +a szolgáltatást. A kliens és szerver folyamatok különböző gépeken lehetnek. + +\subsubsection{Többrétegű architektúrák} + +Az elosztott információs rendszerek gyakran három logikai rétegre (layer vagy tier) vannak tagolva: + +\begin{itemize} + \item Megjelenítés: az alkalmazás felhasználói felületét alkotó komponensekből áll. + \item Üzleti logika: az alkalmazás működését írja le konkrét adatok nélkül + \item Perzisztencia: az adatok tartós tárolása +\end{itemize} + +\subsubsection{Decentralizált architektúrák} + +\noindent \textbf{Peer-to-peer (P2P)}: A csúcsok (peer-ek) között többnyire nincsenek kitüntetett szerepűek.\\ + +\noindent \textbf{Overlay hálózat}: A gráfban szomszédos csúcsok fizikailag lehetnek távol egymástól, +a rendszer elfedi, hogy a köztük lévő kommunikáció több gépen keresztül zajlik. A legtöbb P2P +rendszer overlay hálózatra épül.\\ + +\noindent \textbf{P2P rendszerek fajtái}: +\begin{itemize} + \item Strukturált P2P: A csúcsok által kiadott gráfszerkezet rögzített. A csúcsokat valamilyen struktúra + szerint overlay hálózatba szervezzük és a csúcsoktól az azonosítójuk alapján lehet szolgáltatásokat + igénybe venni. Pl.: elosztott hasítótábla (DHT). + + \item Struktúrálatlan P2P: Az ilyen rendszerek igyekeznek véletlen gráfstruktúrát fenntartani. Mindegyik + csúcsnak csak részleges nézete van a gráfról. Minden $P$ csúcs időnként véletlenszerűen kiválaszt egy $Q$ + szomszédot. $P$ és $Q$ információt cserélnek és elküldik egymásnak az általuk ismert csúcsokat. + + \item Hibrid P2P: néhány csúcsnak speciális szerepe van +\end{itemize} + +\noindent \textbf{Superpeer}: Olyan csúcs, aminek külön feladata van, pl. kereséshez index fenntartása, a hálózat +állapotának felügyelete, csúcsok közötti kapcsolatok létrehozása. + +\section{Elnevezési rendszerek} + +Az elosztott rendszerek entitásai a kapcsolódási pontjaikon (access point) keresztül érhetőek el. Ezeket távolról +a címük azonosítja, amely megnevezi az adott pontot. + +Célszerű lehet az entitást a kapcsolódási pontjaitól függetlenül is elnevezni. Az ilyen nevek helyfüggetlenek (location +independent).\\ + +\noindent \textbf{Egyszerű név}: Nincs szerkezete, tartalmaz véletlen szöveg. Csak összehasonlításra használható.\\ + +\noindent \textbf{Azonosító}: Egy név azonosító, ha egy-egy kapcsolatban áll a megnevezett entitással, és ez +a hozzárendelés maradandó, azaz a név később nem hivatkozhat más egyedre. + +\subsection{Strukturálatlan nevek} + +\subsubsection{Egyszerű megoldások} + +\noindent \textbf{Broadcasting}: Kihirdetjük az azonosítót a hálózaton. Az egyed visszaküldi jelenlegi címét. +Hátrányai: +\begin{itemize} + \item Lokális hálózatokon túl nem skálázódik. + + \item A hálózaton minden gépnek figyelnie kell a beérkező kérésre. +\end{itemize} + +\noindent \textbf{Továbbítómutató}: Amikor az egyed elköltözik, egy mutató marad utána az új helyére. +\begin{itemize} + \item A kliens elől el van fedve, hogy a szoftver továbbítómutató-láncot old fel. + \item A megtalált címet vissza lehet küldeni a klienshez, így a további feloldások gyorsabban mennek. + \item Földrajzi skálázási problémák: + \begin{itemize} + \item A hosszú láncok nem hibatűrőek. + \item A feloldás hosszú időbe telik. + \item Külön mechanizmus szükséges a láncok rövidítésére. + \end{itemize} +\end{itemize} + +\subsubsection{Otthon alapú megoldások} + +\noindent \textbf{Egyrétegű rendszer}: Az egyedhez tartozik egy otthon, ez tartja számon az egyed jelenlegi címét. Az +egyed otthoni címe (home address - HA) be van jegyezve egy névszolgáltatásba. Az otthon számon tartja a jelenlegi +címet (foreign address - FA). A kliens az otthonhoz kapcsolódik, onnan kapja meg a címet.\\ + +\noindent \textbf{Kétrétegű rendszer}: Az egyes környékeken feljegyezzük, hogy mely egyedek tartózkodnak a közelben. +A névfeloldás először ezt a jegyzéket vizsgálja meg és ha az egyed nincs a környéken, akkor kell az otthonhoz fordulni. + +\subsubsection{Elosztott hasítótábla} + +Elosztott hasítótáblát (DHT) készítünk, ebben csúcsok tárolnak egyedeket. Az $N$ csúcs gyűrű overlay szerkezetbe +van szervezve. Minden csúcshoz hozzárendelünk egy $m$ bites azonosítót, és mindegyik entitáshoz egy $m$ bites kulcsot +($N \leq 2^{m}$). A $k$ kulcsú egyed felelőse az az $id$ azonosítójú csúcs, amelyre $k \leq id$, és nincs köztük másik +csúcs. Ezt a csúcsot a kulcs rákövetkezőjének is szokás nevezni: $succ(k)$. Mindegyik $p$ csúcs egy $FT_{p}$ finger +table-t tárol $m$ bejegyzéssel: $FT_{p}[i] = succ (p+2^{i-1})$. Bináris (jellegű) keresést szeretnénk elérni, ezért +minden lépés felezi a keresési tartományt. A $k$ kulcsú egyed kikereséséhez (ha nem a jelenlegi csúcs tartalmazza) +a kérést továbbítjuk ahhoz a $j$ indexű csúcshoz, melyre $FT_{p}[j] \leq k < FT_{p}[j+1]$, illetve, ha +$p\frac{n}{2}$. +Feltesszük, hogy egy esetleges összeomlás után a koordinátor felépül, de a kiadott engedélyeket +elfelejti. + +\subsubsection{Elosztott kölcsönös kizárás} + +Többszörözött az erőforrás. Amikor a kliens hozzá szeretne férni az erőforráshoz, kérést küld a koordinátornak +időbélyeggel ellátva. Választ (hozzáférési engedélyt) akkor kap, ha: + +\begin{itemize} + \item A koordinátor nem igényli az erőforrást, vagy + \item a koordinátor is igényli az erőforrást, de kisebb az időbélyege. + \item Különben a koordinátor átmenetileg nem válaszol. +\end{itemize} + +\begin{figure}[H] + \centering + \includegraphics[width=0.6\linewidth]{img/kolcskizar_elosztott} + \caption{Példa elosztott kölcsönös kizárásra.} + \label{fig:kolcskizar_elosztott} +\end{figure} + +\subsubsection{Kölcsönös kizárás token ring-gel} + +A folyamatokat egy logikai gyűrűbe szervezzük. Egy tokent küldünk körbe. Amelyik folyamat birtokolja a tokent, az +férhet hozzá az erőforráshoz. + +\subsection{Vezetőválasztás} + +Sok algoritmusnak szüksége van arra, hogy kijelöljön egy folyamatot, amely a további lépéseket koordinálja. + +\subsubsection{Zsarnok-algoritmus} + +A folyamatoknak sorszámot adunk, melyek közül a legnagyobb sorszámút szeretnénk vezetőnek választani.\\ + +\noindent A zsarnok-algoritmus lépései: +\begin{enumerate} + \item A vezetőválasztás kezdeményezése. Bármelyik folyamat kezdeményezheti. Mindegyik olyan folyamatnak, + amelyről nem tudja, hogy kisebb lenne az övénél a sorszáma, elküld egy üzenetet. + + \item Ha a nagyobb sorszámú folyamat üzenetet kap egy kisebb sorszámútól, akkor visszaküld neki egy + olyan üzenetet, amivel kiveszi a kisebb sorszámút a választásból. + + \item Amelyik folyamat nem kap letiltó üzenet egy bizonyos időn belül, akkor ő lesz a vezető. Erről + értesíti a többi folyamatot egy-egy üzenettel. +\end{enumerate} + +\begin{figure}[H] + \centering + \includegraphics[width=0.6\linewidth]{img/zsarnok} + \caption{Példa a zsarnok-algoritmus működésére.} + \label{fig:zsarnok} +\end{figure} + +\subsubsection{Vezetőválasztás gyűrűben} + +Logikai gyűrűnk van, a folyamatoknak vannak sorszámai. A legnagyobb sorszámú folyamatot szeretnénk vezetőnek választani. +Bármelyik folyamat kezdeményezhet vezetőválasztást: elindít egy üzenetet a gyűrűn körbe, amelyre mindenki ráírja a +a sorszámát. Ha egy folyamat összeomlott, az kimarad az üzenetküldésből. Amikor az üzenet visszajut a kezdeményezőhöz, +minden aktív folyamat sorszáma szerepel rajta. Ezek közül a legnagyobb sorszámú lesz a vezető. Ezt egy másik +üzenet körbeküldése tudatja mindenkivel. + +Ha több folyamat kezdeményez egyszerre választást, az nem probléma, ugyanaz az eredmény adódik. Ha az üzenetek +elvesznének, akkor újra lehet kezdeni a választást. + +\subsubsection{Superpeer-választás} + +A superpeer-eket úgy szeretnénk megválasztani, hogy teljesüljön rájuk: + +\begin{itemize} + \item A többi csúcs alacsony késleltetéssel éri el őket. + \item Egyenletesen vannak elosztva a hálózaton. + \item A csúcsok megadott hányadát választjuk superpeer-nek. + \item Egy superpeer korlátozott számú peer-t szolgál ki. +\end{itemize} + +\noindent \textbf{Megvalósítás DHT esetén}: Ha $m$-bites azonosítókat használunk, és $S$ superpeer-re van szükség, akkor +a $k= \lceil \log_{2} S \rceil$ felső bitet foglaljuk le a superpeer-ek számára. Így N csúcs esetén kb. $2^{k-m}N$ +superpeer lesz. + +A $p$ kulcshoz tartozó superpeer a $p$ AND $\underbrace{11...11}_{k}\underbrace{00..00}_{m-k}$ kulcs felelőse lesz. + +\section{Konzisztencia} + +\noindent \textbf{Konfliktusos műveletek}: A replikátumok konzisztensen tartásához biztosítani kell, hogy az egymással +konfliktusba kerülhető műveletek minden replikátumon egyforma sorrendben futnak le. Írás-olvasás és írás-írás +konfliktusok fordulhatnak elő.\\ + +\noindent \textbf{Konzisztenciamodell}: A konzisztenciamodell megszabja, milyen módokon használhatják a folyamatok +az adatbázist. Ha a feltételek teljesülnek, az adattárat érvényesnek tekintjük.\\ + +\noindent \textbf{Konzisztencia mértéke}: A konzisztencia többféle módon is sérülhet: eltérhet a replikátumok +számértéke, frissessége, meg nem történt frissítési műveletek száma.\\ + +\noindent \textbf{Conit}: Az olyan adategység, amelyre közös feltételrendszer vonatkozik, a conit (consistency unit). + +\subsection{Soros konzisztencia} + +A feltételeket nem számértékekre, hanem írások/olvasások tényére alapozzuk. +Jelölések: +\begin{itemize} + \item W(x) : x változót írta a folyamat + \item R(x) : x változót olvasta a folyamat +\end{itemize} + +Soros konzisztencia esetén azt várjuk el, hogy a végrehajtás eredménye olyan legyen, mintha az összes folyamat +összes művelete egy meghatározott sorrendben történt volna meg, megőrizve bármely adott folyamat saját műveletinek +sorrendjét. + +\begin{figure}[H] + \centering + \includegraphics[width=0.7\linewidth]{img/konz_soros} + \caption{Példa: az (a) teljesíti, (b) nem a soros konzisztencia követelményeit.} + \label{fig:konz_soros} +\end{figure} + +\subsection{Okozati konzisztencia} + +A potenciálisan okozati összefüggésben álló műveleteket kell mindegyik folyamatnak azonos sorrendben látnia. +A konkurens írásokat a különböző folyamatok különböző sorrendben láthatják. + +\begin{figure}[H] + \centering + \includegraphics[width=0.4\linewidth]{img/konz_okozati} + \caption{Példa: a (b) teljesíti, (a) nem az okozati konzisztencia követelményeit.} + \label{fig:konz_okozati} +\end{figure} + +\subsection{Kliensközpontú konzisztencia} + +Azt helyezzük most előtérbe, hogy a szervereken tárolt adatok hogyan látszanak egy adott kliens számára. A kliens +mozog: különböző szerverekhez csatlakozik, és írási/olvasási műveleteket hajt végre. + +Az $A$ szerver után a $B$ szerverhez csatlakozva különböző problémák léphetnek fel: + +\begin{itemize} + \item Az $A$-ra feltöltött frissítések lehet, hogy nem jutottak még el $B$-hez. + \item $B$-n lehet, hogy újabb adatok találhatóak, mint $A$-n. + \item A $B$-re feltöltött frissítések ütközhetnek az $A$-ra feltöltöttekkel. +\end{itemize} + +A cél az, hogy a kliens azokat az adatokat, amiket az $A$ szerveren kezelt, ugyanolyan állapotban +lássa $B$-n is. Ekkor az adatbázis konzisztensnek látszik a kliens számára.\\ + +\subsubsection{Monoton olvasás} +Ha egyszer a kliens kiolvasott egy értéket $x$-ből, minden ezután következő +olvasás ezt adja, vagy ennél frissebb értéket. + +Például levelezőkliens esetén minden korábban letöltött levelünknek meg kell lennie az új szerveren is. + +\subsubsection{Monoton írás} + +A kliens akkor írhatja $x$-et, ha kliens korábbi írásai $x$-re már befejeződtek. + +Például verziókezelésnél minden korábbi verziónak meg kell lennie a szerveren, ha új verziót akarunk feltölteni. + +\subsubsection{Olvasd az írásodat} + +Ha kliens olvassa $x$-et, a saját legutolsó írásának eredményét kapja, vagy frissebbet. + +Például a kliens a honlapját szerkeszti, majd megnézi az eredményt. Ahelyett, hogy a böngésző gyorsítótárából +egy régebbi változat kerülne elő, a legfrissebbet szeretné látni. + +\subsubsection{Írás olvasás után} + +Ha a kliens kiolvasott egy értéket $x$-ből, minden ezután kiadott frissítési művelete $x$-nek legalább +ennyire friss értékét módosítja. + +Például egy fórumon a kliens csak olyan hozzászólásra tud válaszolni, amit már látott. + +\subsection{Tartalom replikálása} + +Különböző jellegű folyamatok tárolhatják a másolatokat: + +\begin{itemize} + \item Tartós másolat: eredetszerver (origin server) + \item Szerver által kezdeményezett másolat: replikátum kihelyezése egy szerverre, amikor az igényli + az adatot + \item Kliens által kezdeményezett másolat: kliensoldali gyorsítótár +\end{itemize} + +\subsubsection{Frissítés terjesztése} +Megváltozott tartalmat több különféle módon lehet kliens-szerver architektúrában átadni: + +\begin{itemize} + \item Kizárólag a frissítésről szóló értesítés/érvénytelenítés elterjesztése. + \item Passzív replikáció: adatok átvitele egyik másolatról a másikra + \item Aktív replikáció: frissítési művelet átvitele +\end{itemize} + +A frissítést kezdeményezheti a szerver (küldésalapú frissítés), ekkor a szerver a kliens kérése nélkül elküldi a frissítést +a kliensnek, vagy kezdeményezheti a kliens, aki kérvényezi a frissítést a szervertől (rendelésalapú frissítés).\\ + +\noindent \textbf{Haszonbérlet (lease)}: A szerver ígéretet tesz a kliensnek, hogy átküldi a frissítést, amíg a haszonbérlet aktív. + +\end{document} \ No newline at end of file diff --git a/17.Osztott rendszerek/img/atlatszosag.png b/19. Osztott rendszerek és konkurens programozás/img/atlatszosag.png similarity index 100% rename from 17.Osztott rendszerek/img/atlatszosag.png rename to 19. Osztott rendszerek és konkurens programozás/img/atlatszosag.png diff --git a/17.Osztott rendszerek/img/clockspeed.png b/19. Osztott rendszerek és konkurens programozás/img/clockspeed.png similarity index 100% rename from 17.Osztott rendszerek/img/clockspeed.png rename to 19. Osztott rendszerek és konkurens programozás/img/clockspeed.png diff --git a/17.Osztott rendszerek/img/dht.png b/19. Osztott rendszerek és konkurens programozás/img/dht.png similarity index 100% rename from 17.Osztott rendszerek/img/dht.png rename to 19. Osztott rendszerek és konkurens programozás/img/dht.png diff --git a/17.Osztott rendszerek/img/dns.png b/19. Osztott rendszerek és konkurens programozás/img/dns.png similarity index 100% rename from 17.Osztott rendszerek/img/dns.png rename to 19. Osztott rendszerek és konkurens programozás/img/dns.png diff --git a/17.Osztott rendszerek/img/hls_insert.png b/19. Osztott rendszerek és konkurens programozás/img/hls_insert.png similarity index 100% rename from 17.Osztott rendszerek/img/hls_insert.png rename to 19. Osztott rendszerek és konkurens programozás/img/hls_insert.png diff --git a/17.Osztott rendszerek/img/kolcskizar_elosztott.png b/19. Osztott rendszerek és konkurens programozás/img/kolcskizar_elosztott.png similarity index 100% rename from 17.Osztott rendszerek/img/kolcskizar_elosztott.png rename to 19. Osztott rendszerek és konkurens programozás/img/kolcskizar_elosztott.png diff --git a/17.Osztott rendszerek/img/kolcskizar_kozp.png b/19. Osztott rendszerek és konkurens programozás/img/kolcskizar_kozp.png similarity index 100% rename from 17.Osztott rendszerek/img/kolcskizar_kozp.png rename to 19. Osztott rendszerek és konkurens programozás/img/kolcskizar_kozp.png diff --git a/17.Osztott rendszerek/img/konz_okozati.png b/19. Osztott rendszerek és konkurens programozás/img/konz_okozati.png similarity index 100% rename from 17.Osztott rendszerek/img/konz_okozati.png rename to 19. Osztott rendszerek és konkurens programozás/img/konz_okozati.png diff --git a/17.Osztott rendszerek/img/konz_soros.png b/19. Osztott rendszerek és konkurens programozás/img/konz_soros.png similarity index 100% rename from 17.Osztott rendszerek/img/konz_soros.png rename to 19. Osztott rendszerek és konkurens programozás/img/konz_soros.png diff --git a/17.Osztott rendszerek/img/nevter.png b/19. Osztott rendszerek és konkurens programozás/img/nevter.png similarity index 100% rename from 17.Osztott rendszerek/img/nevter.png rename to 19. Osztott rendszerek és konkurens programozás/img/nevter.png diff --git a/17.Osztott rendszerek/img/rpc.png b/19. Osztott rendszerek és konkurens programozás/img/rpc.png similarity index 100% rename from 17.Osztott rendszerek/img/rpc.png rename to 19. Osztott rendszerek és konkurens programozás/img/rpc.png diff --git a/17.Osztott rendszerek/img/socket.png b/19. Osztott rendszerek és konkurens programozás/img/socket.png similarity index 100% rename from 17.Osztott rendszerek/img/socket.png rename to 19. Osztott rendszerek és konkurens programozás/img/socket.png diff --git a/17.Osztott rendszerek/img/zsarnok.png b/19. Osztott rendszerek és konkurens programozás/img/zsarnok.png similarity index 100% rename from 17.Osztott rendszerek/img/zsarnok.png rename to 19. Osztott rendszerek és konkurens programozás/img/zsarnok.png diff --git a/2. Differenciál- és integrálszámítás/2. Differenciál- és integrálszámítás.pdf b/2. Differenciál- és integrálszámítás/2. Differenciál- és integrálszámítás.pdf new file mode 100644 index 0000000..b9b7eb1 Binary files /dev/null and b/2. Differenciál- és integrálszámítás/2. Differenciál- és integrálszámítás.pdf differ diff --git a/2. Differenciál- és integrálszámítás/2. Differenciál- és integrálszámítás.tex b/2. Differenciál- és integrálszámítás/2. Differenciál- és integrálszámítás.tex new file mode 100644 index 0000000..0e31845 --- /dev/null +++ b/2. Differenciál- és integrálszámítás/2. Differenciál- és integrálszámítás.tex @@ -0,0 +1,392 @@ +\documentclass[margin=0px]{article} + +\usepackage{listings} +\usepackage[utf8]{inputenc} +\usepackage{graphicx} +\usepackage{float} +\usepackage[a4paper, margin=0.7in]{geometry} +\usepackage{subcaption} +\usepackage{amsthm} +\usepackage{amssymb} +\usepackage{amsmath} +\usepackage{fancyhdr} +\usepackage{setspace} + +\onehalfspacing + +\renewcommand{\figurename}{ábra} +\newenvironment{tetel}[1]{\paragraph{#1 \\}}{} +\newcommand{\R}{\mathbb{R}} + +\pagestyle{fancy} +\lhead{\it{PTI BSc Záróvizsga tételek}} +\rhead{2. Differenciál- és integrálszámítás} + +\title{\textbf{{\Large ELTE IK - Programtervező Informatikus BSc} \vspace{0.2cm} \\ {\huge Záróvizsga tételek}} \vspace{0.3cm} \\ 2. Differenciál- és integrálszámítás} +\author{} +\date{} + +\begin{document} +\maketitle + +\begin{tetel}{Differenciál- és integrálszámítás} + Függvények deriválhatósága. Parciális derivált, totális derivált. Gradiens, Jacobi-mátrix. Függvényvizsgálat, szélsőérték. Riemann-integrál, parciális integrálás, integrálás helyettesítéssel. Newton-Leibniz-formula. +\end{tetel} + +\section{Függvények deriválhatósága} +\begin{description} + \item[Differenciálhatóság] \hfill \\ + $ 1 \leq n, m \in \mathbb{N}, \quad 1 \leq p,q \leq +\infty,$ + + $ (\R^n, \lVert . \rVert_p)$ és $ (\R^m, \lVert . \rVert_q)$ normált terek + + $ f \in \R^n \rightarrow \R^m, \ a \in intD_f $ + + Az $f$ függvény differenciálható az $a$ pontban ($ f \in D\{a\}$) , ha\\ + létezik olyan $ L \in L(\R^n, \R^m)$ korlátos lineáris leképezés és olyan $ \eta \in \R^n \rightarrow \R^m $ függvény, hogy : + \begin{align*} + f(a+h)-f(a) = L(h)+\eta(h)\cdot \lVert h\rVert_p \quad ( h \in \R^n, a+h \in D_f) + \end{align*} + ahol + \begin{align*} + \eta(h) \longrightarrow 0 \quad (\lVert h\rVert_p \rightarrow 0) + \end{align*} + + Más szóval: + + \[ \dfrac{f(a+h)-f(a)-L(h)}{\lVert h\rVert_p} \longrightarrow 0 \quad (\lVert h\rVert_p \rightarrow 0)\] + \\\\ + Amennyiben $\forall a\in intD_f : f \in D\{a\} $, akkor az $f$ differenciálható ($f \in D$) + \\\\ + \textit{ + Megjegyzés:\\ + A $ \mathbb{K}$ test feletti $ (X, \lVert.\rVert_\bigstar )$, $ (X, \lVert.\rVert_\heartsuit )$ normált terek közötti folytonos leképezés, korlátos lineáris leképezés, ha + \begin{itemize} + \item lineáris, azaz + \begin{align*} + f(x+\lambda y) = f(x) + \lambda f(y) \quad (x,y \in X, \lambda \in \mathbb{K}) + \end{align*} + \item korlátos, azaz + \begin{align*} + \exists M \geq 0 : \lVert f(x) \rVert_\heartsuit \leq M\lVert x \rVert_\bigstar \quad (x \in X) + \end{align*} + \end{itemize} + } + \item[Derivált] \hfill \\ + $f\in\R^n\rightarrow\R^m $ függvény differenciálható egy $a\in intD_f$ pontban \\ + $ \Rightarrow \exists! L\in L(\R^n,\R^m)$ korlátos lineáris leképezés + + Ezt az egyértelműen létező $L \in L(\R^n,\R^m) $ korlátos lineáris leképezést az $f$ függvény $a$ pontbeli deriváltjának nevezzük, és $f'(a)$ szimbólummal jelöljük. +\end{description} + +\section{Parciális derivált, Totális derivált} +\subsection{Parciális derivált} +\begin{description} + \item[Definíció] \hfill \\ + Tekintsük a $ h \in \R^n \rightarrow \R $ függvényt és az $a = (a_1, ... , a_n) \in D_h $ vektort. Legyen + \begin{align*} + D_{h,i}^{(a)} := \{t \in \R : (a_1, ..., a_{i-1}, t, a_{i+1}, ..., a_n) \in D_h\} \quad (i = 1,...,n) + \end{align*} + És legyen: + \begin{align*} + h_{a,i} : D_{h,i}^{(a)} \rightarrow \R, \quad \textrm{ melyre: } \quad h_{a,i}(t) := h(a_1, ..., a_{i-1}, t, a_{i+1}, ..., a_n) \quad (t\in D_{h,i}^{(a)} ) + \end{align*} + A $h_{a,i}$ parciális függvények mind egyváltozós valós függvények ($h_{a,i} \in \R \rightarrow\R $) + + A $ h $ függvény az $a$-ban $i$-edig változó szerint parciálisan deriválható, ha $ h_{a,i} \in D\{a_i\} $. Ekkor: + \begin{align*} + \partial_ih(a) := h'_{a,i}(a_i) + \end{align*} + valós számot a $h$ függvény $a$-beli, $i$-edik változó szerinti parcális deriváltjának nevezzük. + \item[Parciális derivált függvény] \hfill \\ + Tegyük fel, hogy az előző $h$ függvényre: + \begin{align*} + D_{h,i} := \{a \in D_h : \textrm{létezik a } \partial_ih(a) \textrm{parciáis derivált}\} \neq \emptyset \qquad (i=1,...,n) + \end{align*} + Ekkor a + \begin{align*} + x \mapsto \partial_ih(x) \quad (x\in D_{h,i}) + \end{align*} + függvényt a $h$ függvény $i$-edik változó szerinti parciális deriváltfüggvényének nevezzük, és a $\partial_ih$ szimbólummal jelöljük. + \item[Differenciálhatóság és parciális differenciálhatóság] \hfill + \begin{itemize} + \item Differenciálhatóság $\Rightarrow$ parciális differenciálhatóság \\ + $ 1 \leq n \in \mathbb{N}, \ h \in \R^n \rightarrow \R, $ és $h\in D\{a\} \ (a \in D_h) $ \\ + $\Rightarrow \forall i = 1,...,n$ : a $h$ függvény $i$-edik változó szerint parciálisan differenciálható az $a$ pontban, és + \begin{align*} + \textrm{grad}h(a) = (\partial_1h(a), ..., \partial_nh(a)) + \end{align*} + + \item Differenciálhatóság $\Leftarrow$ parciális differenciálhatóság \\ + $ 1 \leq n \in \mathbb{N}, \ h \in \R^n \rightarrow \R, $ és $ a \in intD_h $ \\ + Valamilyen $i = 1,...,n$ esetén: + \begin{itemize} + \item Tetszőleges $ x \in K_r(a) $ ($r > 0$ alkalmas) helyen léteznek a $ \partial_jh(x)$ parciális deriváltak $ (i \neq j = 1,...,n)$ és ezek folytonosak + \item $\exists \ \partial_ih(a)$ parciális derivált + \end{itemize} + $\Rightarrow h\in D(a)$ + \end{itemize} +\end{description} +\subsection{Totális derivált} +\rm Az $ f: \R^p \to \R^q $ függvényt {\it (totálisan) differenciálhatónak\,} mondjuk az $a\in D(f)$ pontban, +ha létezik egy $ L: \R^p \to \R^q $ lineáris leképezés úgy, hogy +$$ + \lim_{x\to a}\frac{f(x)-f(a)-L(x-a)}{\|x-a\|}=0. +$$ +Az $L$ lineáris leképezést az $f$ függvény $a$ pontbeli {\it differenciáljának,} az $L$ leképezés $M_L$ mátrixát pedig +$f$ $a$-beli {\it differenciálhányadosának vagy Jacobi-mátrixának\,} nevezzük. Jelölés: $L=Df(a)$, illetve $M_L=f'(a)$. + +Valós $f$ esetén ($q=1$) az $f'(a)$ Jacobi-mátrix $1\times p$ típusú, azaz $p$ dimenziós sorvektor. Ebben az esetben az $a$ +pontbeli Jacobi-mátrix helyett az $a$ pontbeli {\it gradiens {\rm vagy} gradiensvektor\,} elnevezés és az $f'(a)=\operatorname{grad} f(a)$ +jelölés is használatos. + +\section{Jacobi-mátrix, gradiens} +\begin{description} + \item[Jacobi-mátrix] \hfill \\ + Az előzőekben szereplő $L := f'(a) $ korlátos lineáris leképezéshez $ \exists!A\in\R^{m\times n}$ mátrix, melyre: + \begin{align*} + L(x) = Ax \quad (x\in\R^n) + \end{align*} + Ezért: + $ f'(a) := A $\\ + az $f$ függvény $a$-beli deriváltja vagy derivált mátrixa, más néven Jacobi-mátrixa. + \item[Gradiens] \hfill \\ + $m = 1$ esetén : $ f \in \R^n \rightarrow \R $ + \begin{align*} + \textrm{grad}f(a) := f'(a) \in \R^{1\times n} \approx \R^n + \end{align*} + Tehát ebben az esetben az $f'(a)$ Jacobi-mátrix tekinthető egy $\R^n$-beli vektornak, amit az $f$ függvény $a$-beli gradiensének nevezünk. + \\\\ + Ha $ D := \{a \in D_f : f \in D\{a\} \} $, akkor az + \begin{align*} + x \mapsto \textrm{grad}f(x) \in \R^n \quad (x \in D) + \end{align*} + függvényt az $f$ függvény gradiensének nevezzük, és grad$f \in \R^n \rightarrow \R^n$ jelöljük. + \item[Gradiens mint Jacobi-mátrix sora] \hfill \\ + Legyen $1 \leq n, m \in \mathbb{N}$. Az $f = (f_1, ..., f_m) \in \R^n \rightarrow \R^m$ függvény akkor és csak akkor differenciálható az $ a \in intD_f$ helyen, ha minden $ i = 1, ..., m $ esetén az + $f_i \in \R^n \rightarrow \R$ koordináta-függvény differenciálható az $a$-ban. + + Ha $f \in D\{a\}$, akkor az $f'(a)$ Jacobi-mátrix a következő alakú: + \begin{align*} + f'(a) = + \begin{bmatrix} + \textrm{grad}f_{1}(a) \\ + \textrm{grad}f_{2}(a) \\ + \vdots \\ + \textrm{grad}f_{m}(a) \\ + \end{bmatrix} + \end{align*} +\end{description} + +\section{Szélsőérték, függvényvizsgálat} +\subsection{Szélsőérték} +$ f \in \R \rightarrow \R, a \in D_f$ +\begin{description} + \item[Lokális maximum] \hfill \\ + $f$-nek $a$-ban lokális maximuma van, ha alkalmas $ r > 0$ mellett: \\ + $ f(x) \leq f(a) \qquad (x\in D_f, |x-a| 0$ mellett: \\ + $ f(x) \geq f(a) \qquad (x\in D_f, |x-a| 0 ) $ + \begin{enumerate} + \item $f$ függvénynek $ (-,+) $ jelváltása van, ha \\ + $ f(x) \leq 0 \leq f(t), \quad (x,t \in K_r(a), \ x 0 ) $ + \begin{enumerate} + \item $f'$-nak az $a$-ban $(+,-)$ jelváltása van $\Rightarrow f$-nek $a$-ban lokális maximuma van. + \item $f'$-nak az $a$-ban $(-,+)$ jelváltása van $\Rightarrow f$-nek $a$-ban lokális minimuma van. + \end{enumerate} +\end{description} +\subsection{Monotonitás} +$ f\in \R \rightarrow \R $ +\begin{description} + \item[Monoton növekedés] \hfill \\ + $ f $ monoton növő ($\nearrow$), ha $\forall x,t \in D_f, \ x < t : f(x) \leq f(t) $. \\ + Amennyiben $ f(x) < f(t) $, akkor $f$ szigorúan monoton növő ($\uparrow$). + \item[Monoton fogyás (csökkenés)] \hfill \\ + $ f $ monoton fogyó ($\searrow$), ha $\forall x,t \in D_f, \ x < t : f(x) \geq f(t) $. \\ + Amennyiben $ f(x) > f(t) $, akkor $f$ szigorúan monoton fogyó ($\downarrow$). + \item[Derivált és monotonitás kapcsolata] \hfill \\ + $ I \subset \R $ nyílt intervallum, $ f:I\rightarrow \R, \ f \in D$\\ + $\Rightarrow$ + \begin{enumerate} + \item $ f \nearrow \ \Leftrightarrow \ f' \geq 0$ + \item $ f \searrow \ \Leftrightarrow \ f' \leq 0$ + \item $ f \ konstans \ \Leftrightarrow \ \forall x \in I : f'(x) = 0$ + \item $ \forall x \in I : f'(x) > 0 \ \Rightarrow \ f \uparrow $ + \item $ \forall x \in I : f'(x) < 0 \ \Rightarrow \ f \downarrow $ + \end{enumerate} +\end{description} +\subsection{Alaki viszonyok} +\begin{description} + \item[Konvexitás, konkávitás] \hfill \\ + $ I \subset \R $ intervallum, $ f:I\rightarrow \R $ + \begin{itemize} + \item $f$ konvex, ha \\ + $\forall a,b \in I \quad \forall 0\leq \lambda \leq 1: f(\lambda a+(1-\lambda)b) \leq \lambda f(a) + (1-\lambda)f(b)$ + \item $f$ konkáv, ha \\ + $\forall a,b \in I \quad \forall 0\leq \lambda \leq 1: f(\lambda a+(1-\lambda)b) \geq \lambda f(a) + (1-\lambda)f(b)$ + \end{itemize} + \begin{figure}[H] + \centering + \includegraphics[width=0.6\textwidth]{img/konvex.png} + \caption{Konvex függvény} + \end{figure} + \item[Konvexitás és derivált] \hfill \\ + $ I \subset \R $ nyílt intervallum, $f:I\rightarrow \R, \ f \in D $ + \begin{itemize} + \item $f$ konvex $ \Leftrightarrow f' \nearrow $ + \item $f$ konkáv $ \Leftrightarrow f' \searrow $ + \end{itemize} + \item[Inflexió] \hfill \\ + $ f \in \R \rightarrow \R, \ a \in intD_f, \ f \in D\{a\} $: + \begin{description} + \item[Pontbeli érintő] \hfill \\ + $ e_a(x) := f(a) + f'(a)(x-a) \quad (x\in\R)$ + \item[Inflexió] \hfill \\ + $ f$-nek az $a$-ban inflexiója van, ha az $f - e_a(f) $ az $a$-ban jelet vált. + \end{description} + \begin{figure}[H] + \begin{subfigure}{.33\textwidth} + \centering + \includegraphics[width=0.7\textwidth]{img/inflexio_x3.png} + \caption{$x^3$ függvény inflexiója} + \end{subfigure} + \begin{subfigure}{.33\textwidth} + \centering + \includegraphics[width=0.7\textwidth]{img/inflexio_sin.png} + \caption{szinusz függvény inflexiója} + \end{subfigure} + \begin{subfigure}{.33\textwidth} + \centering + \includegraphics[width=0.7\textwidth]{img/inflexio_x2.png} + \caption{$x^2$-nek nincs inflexiója} + \end{subfigure} + \end{figure} +\end{description} +\subsection{Többször differenciálható függvények} +\begin{description} + \item[Második derivált] \hfill \\ + $ f \in \R \rightarrow \R, \ a \in intD_f, $ és \\ + $ f \in D\{x\} \quad (x \in K_r(a), r>0)$, illetve $f' \in D\{a\}$ \\ + Ekkor $f$ az $a$-ban kétszer deriválható és $f''(a) := (f')'(a) $ az $f$ második deriváltja. + \item[Differenciálás magasabb rendben] \hfill \\ + Hasonlóképpen az előzőhöz:\\ + $ f \in \R \rightarrow \R, \ a \in intD_f, $ és \\ + $ f \in D^n\{x\} \quad (x \in K_r(a), r>0)$, illetve $f^{(n)} \in D\{a\}, \ (1 \leq n \in \mathbb{N})$ \\ + Ekkor $f$ az $a$-ban $(n+1)$-szer deriválható és $f^{(n+1)}(a) := (f^{(n)})'(a) $ az $f \ (n+1)$-edik deriváltja. + \item[Másodrendű elégséges feltétel (lokális szélsőérték létezésére)] \hfill \\ + $ f \in D^2\{a\}$ függvényre $f'(a) = 0$ és $f''(a) \neq 0 $ \\ + $ \Rightarrow f$-nek az $a$-ban szigorú lokális szélsőértéke van. \\ + Ha $f''(a) < 0 \Rightarrow $ szigorú lokális maximum. \\ + Ha $f''(a) > 0 \Rightarrow $ szigorú lokális minimum. +\end{description} +\section{Riemann-integrál, parciális integrálás, integrálás helyettesítéssel.} +\begin{description} + \item[Primitív függvény] \hfill \\ + $ I \subset \R $ nyílt intervallum, $ f \in I \rightarrow \R $ \\ + Ha $ \exists F:I\rightarrow\R $, hogy $ F \in D $, $F' = f$ \\ + akkor $ F $ az $ f $ primitív függvénye. + + \item[Határozatlan integrál] \hfill \\ + Legyen $ \int{f} := \int f(x)dx := \{F:I \rightarrow \R, F \in D $ + és $ F' = f \} $ az f határozatlan integrálja. + + \item[Határozott integrál (Riemann-integrál)] \hfill \\ + $ -\infty < a < b < \infty$ + $, f:[a,b] \rightarrow \R, f $ korlátos + \begin{itemize} + \item + A $ \tau \subset [a,b] $ felosztása, ha $ \tau $ véges és $ a,b \in \tau $ \\ + Ekkor $ \tau = \{x_0, x_1, ..., x_n \} (n \in \mathbb{N}) $, ahol + $ a := x_0 < x_1 < ... < x_n := b$ + \item + $ m_i := m_i(f) := inf\{f(x): x_i \leq x \leq x_{i+1} \} (i = 0..n-1)$, illetve \\ + $ M_i := M_i(f) := sup\{f(x): x_i \leq x \leq x_{i+1} \} (i = 0..n-1)$ + + és: + + $ s(f, \tau) := \sum\limits_{i=0}^{n-1} m_i(x_{i+1} - x_i) $ - alsó összeg \\ + $ S(f, \tau) := \sum\limits_{i=0}^{n-1} M_i(x_{i+1} - x_i) $ - felső összeg + + \item + $ \mathfrak{F} := \{ \tau \subset [a,b] $ felosztás $\}$ + \item + Az $ \{ s(f, \tau): \tau \in \mathfrak{F} \} $ felülről korlátos és $ \forall \mu \in \mathfrak{F} : S(f, \mu) $ felső korlát, illetve \\ + Az $ \{ S(f, \tau): \tau \in \mathfrak{F} \} $ alulról korlátos és $ \forall \mu \in \mathfrak{F} : s(f, \mu) $ alsó korlát + \item + Tehát legyen: \\ $ I_*(f) := sup\{ s(f,\tau) : \tau \in \mathfrak{F} \}$ - Darboux alsó index, és \\ + $ I^*(f) := inf\{ S(f,\tau) : \tau \in \mathfrak{F} \}$ - Darboux felső index + \end{itemize} + + $ \Rightarrow \forall \tau,\mu \in \mathfrak{F} : s(f, \tau) \leq I_*(f) \leq I^*(f) \leq S(f,\mu) $ + + Az $ f $ függvény Riemann-integrálható ($ f \in R[a,b] $), ha $ I_*(f) = I^*(f) $, ekkor legyen \\ + $ \int_{a}^{b}f := \int_{[a,b]}f := \int_{a}^{b}f(x) dx := I_*(f) = I^*(f) $ az $f$ függvény Riemann-integrálja (határozott integrálja). + + \item[Parciális integrálás] \hfill + \begin{itemize} + \item Határozatlan esetben \hfill \\ + $ I \subset \R $ nyílt intervallum, $ f,g : I \rightarrow \R $, $f,g \in D$ és \\ + $ fg'$-nek van primitív függvénye (azaz $ \int fg' \neq \emptyset $)\\ + $ \Rightarrow \int f'g \neq \emptyset $ és $ \int f'g = fg - \int fg' $ + \item Határozott esetben \hfill \\ + $ f,g \in D[a,b] \\ f'g, f g' \in R[a,b] $ \\ + $ \Rightarrow \int_a^b f'g = f(b)g(b) - f(a)g(a) - \int_a^b fg'$ + \end{itemize} + + \item[Integrálás helyettesítéssel] \hfill + \begin{itemize} + \item Határozatlan esetben \hfill \\ + $ I,J \subset \R $ nyílt intervallumok, $g: I \rightarrow J, g \in D, f:J \rightarrow \R, \int f \neq \emptyset $ \\ + $\Rightarrow \int f \circ g\cdot g' \neq \emptyset $ és $ (\int f) \circ g = \int(f\circ g\cdot g') $ + \item Határozott esetben \hfill \\ + $ f \in C[a,b], g : [\alpha,\beta] \rightarrow [a,b], g \in C^1[\alpha,\beta],$\\ + $g(\alpha) = a, g(\beta) = b $ \\ + $ \Rightarrow \int_a^b f = \int_{\alpha}^{\beta} (f\circ g \cdot g')$ + \end{itemize} +\end{description} +\section{Newton-Leibniz-formula} + +$ f \in R[a,b], \exists F:[a,b] \rightarrow \R, F $ folytonos és $ F \in D\{x\}, F'(x) = f(x), (a < x < b) $ \\ +$ \Rightarrow \int_a^b f = F(b) - F(a) $ + +\end{document} \ No newline at end of file diff --git a/2. Differenciál- és integrálszámítás/2.1 Differenciálegyenletek.pdf b/2. Differenciál- és integrálszámítás/2.1 Differenciálegyenletek.pdf new file mode 100644 index 0000000..eb77b88 Binary files /dev/null and b/2. Differenciál- és integrálszámítás/2.1 Differenciálegyenletek.pdf differ diff --git a/2. Differenciál- és integrálszámítás/2.1 Differenciálegyenletek.tex b/2. Differenciál- és integrálszámítás/2.1 Differenciálegyenletek.tex new file mode 100644 index 0000000..e93efb5 --- /dev/null +++ b/2. Differenciál- és integrálszámítás/2.1 Differenciálegyenletek.tex @@ -0,0 +1,176 @@ +\documentclass[margin=0px]{article} + +\usepackage{listings} +\usepackage[utf8]{inputenc} +\usepackage{graphicx} +\usepackage{float} +\usepackage[a4paper, margin=1in]{geometry} +\usepackage{subcaption} +\usepackage{amsthm} +\usepackage{amssymb} +\usepackage{amsmath} +\usepackage{fancyhdr} + +\renewcommand{\figurename}{ábra} +\newenvironment{tetel}[1]{\paragraph{#1 \\}}{} +\newcommand{\R}{\mathbb{R}} + +\pagestyle{fancy} +\lhead{\it{PTI BSc Záróvizsga tételek}} +\rhead{2.1 Differenciálegyenletek} + +\title{\textbf{{\Large ELTE IK - Programtervező Informatikus BSc} \vspace{0.2cm} \\ {\huge Záróvizsga tételek}} \vspace{0.3cm} \\ 2.1 Differenciálegyenletek} +\author{} +\date{} + +\begin{document} +\maketitle + +\section{A kezdeti érték probléma} +\begin{description} + \item[Differenciál egyenlet] \hfill \\ + $ 0 < n \in \mathbb{N}, \ I \subset \R$ nyílt intervallum, \\ + $ \Omega := I_1 \times ... \times I_n \subset \R^n$, ahol $ I_1,...,I_n \subset \R$ nyílt intervallum \\ + $f:I\times\Omega \rightarrow \R^n, \ f \in C $ + + Határozzuk meg a $ \varphi \in I \rightarrow \Omega$ függvényt úgy, hogy: + \begin{itemize} + \item $ D_{\varphi} $ nyílt intervallum + \item $ \varphi \in D $ + \item $ \varphi'(x) = f(x, \varphi(x)) \quad (x \in D_{\varphi}) $ + \end{itemize} + + Ezt a feladatot nevezzük differenciál egyenletnek. + \item[Kezdeti érték probléma] \hfill \\ + Ha az előzőekhez még adottak: $ \tau \in I$, és $ \xi \in \Omega$ \\ + Illetve a $\varphi$ függvényre még teljesül: + \begin{itemize} + \item $\tau \in D_{\varphi}$ és $ \varphi(\tau) = \xi $ + \end{itemize} + + Akkor kezdeti érték problémának (Cauchy feladatnak) nevezzük. +\end{description} +\section{Lineáris, ill. magasabb rendű lineáris differenciálegyenletek} +\subsection{Lineáris differenciálegyenletek} +\begin{description} + \item[Definíció] \hfill \\ + A lineáris differenciálegyenlet olyan differenciálegyenlet, melyre:\\ + $ n=1, \quad I,I_1 \subset \R $ nyílt intervallumok, $f:I\times I_1 \rightarrow \R$, ahol \\ + $g,h : I \rightarrow \R, \ g,h \in C, \ I_1 := \R$ és \\ + $f(x,y) := g(x)\cdot y + h(x) \quad (x \in I, y \in I_1 = \R) $\\ + $ \Rightarrow \varphi'(x) = f(x, \varphi(x)) = g(x) \cdot \varphi(x) + h(x) \quad (x \in D_{\varphi})$ + \item[Homogenitás] \hfill \\ + A lineáris differenciálegyenlet homogén ha $ h \equiv 0$ (különben inhomogén) + \item[Kezdeti érték probléma] \hfill + \begin{itemize} + \item Minden lineáris differenciálegyenletre vonatkozó kezdeti érték probléma megoldható és \\ + $\forall \varphi, \psi $ megoldásokra: $ \varphi(t) = \psi(t) \quad (t \in D_{\varphi} \cap D_{\psi} )$ + \item Minden homogén lineáris differenciálegyenlet ($\varphi : I \rightarrow \R$) megoldása a következő alakú: \\ + $ c\varphi_0$, ahol \\ + $c \in \R$ és $\varphi_0(t) = e^{G(t)} \quad (G:I\rightarrow\R, \ G \in D, $ és $ G' = g)$ + \item Állandók variálásának módszere:\\ + $ \exists m:I\rightarrow\R, \ m \in D : m\cdot\varphi_0$ megoldása az (inhomogén) lineáris differenciálegyenletnek + \item Partikuláris megoldás: \\ + $M := \{ \varphi : I \rightarrow \R : \varphi'(t) = g(t)\cdot\varphi(t) + h(t) \ (t \in I)\} $ \\ + $M_h := \{ \varphi : I \rightarrow \R : \varphi'(t) = g(t)\cdot\varphi(t) \ (t \in I)\} $\\ + $\Rightarrow \forall \psi \in M : M = \psi + M_h = \{\varphi + \psi : \varphi \in M_h\}$\\ + (És itt $\psi$ az előzőek alapján $m\cdot\varphi_0$ alakban írható) + \item Példa: Radioaktív bomlás: \\ + $ m_0 > 0$ - kezdeti anyagmennyiség \\ + $ m \in \R \rightarrow \R $ - tömeg-idő függvénye, ahol \\ + $m(t)$ - a meglévő anyag mennyisége \\ + $ m \in D \Rightarrow \dfrac{m(t) - m(t+\Delta t)}{\Delta t} \quad (\Delta t \neq 0) $ - átlagos bomlási sebesség \\ + $ \dfrac{m(t) - m(t+\Delta t)}{\Delta t} \xrightarrow[\Delta t \rightarrow 0]{} -m'(t) $, ami megfigyelés alapján $ \approx m(t)$ \\ + + azaz: \\ + $ m'(t) = - \alpha \cdot m(t) \quad (t\in\R, 0 < \alpha \in \R)$\\ + $ m(0) = m_0 $ \\ + \rule{3cm}{0.2pt} \\ + Homogén lineáris differenciálegyenlet (kezdeti érték probléma): \\ + $ g \equiv -\alpha, \ \tau :=0, \ \xi := m_0 $ \\ + $ \Rightarrow G(t) = -\alpha t \quad (t\in\R) \Rightarrow \varphi_0(t) = e^{-\alpha t} \quad (t \in \R)$ \\ + $ \Rightarrow \exists c \in \R : m(t) = c\cdot e^{-\alpha t} \quad (t \in \R)$, ahol \\ + $m(0) = c = m_0 \Longrightarrow m(t) = m_0e^{-\alpha t} \quad (t \in \R)$ \\ + Ha $ T \in \R : m(T) = \dfrac{m_0}{2} $ (felezési idő) \\ + $\Rightarrow \dfrac{m_0}{2} = m_0e^{-\alpha T} \Rightarrow \dfrac{1}{2} = e^{-\alpha T} \Rightarrow e^{\alpha T} = 2$ \\ + $\Rightarrow T = \dfrac{ln(2)}{\alpha} $ + \end{itemize} +\end{description} +\subsection{Magasabb rendű lineáris differenciálegyenletek} +\begin{description} + \item[Definíció] \hfill \\ + $ 0 < n \in \mathbb{N}, I \subset \R$ nyílt, $ a_0, ... ,a_{n-1} :I \rightarrow \R$ folytonos és $ c: I \rightarrow \R$ folytonos. \\ + Keressünk olyan $ \varphi \in I \rightarrow \mathbb{K}$ függvényt, melyre: + \begin{itemize} + \item $ \varphi \in D^n$ + \item $ D_{\varphi}$ nyílt intervallum + \item $ \varphi^{(n)}(x) + \sum\limits_{k=0}^{n-1}a_k(x) \cdot \varphi^{(k)}(x) = c(x) \quad (x \in D_{\varphi}) $ + \end{itemize} + + Ezt $n$-edrendű lineáris differenciálegyenletnek nevezzük. ($n=1$ esetben Lineáris diff. egyenlet). Ha még: \\ + $ \tau \in I, \ \xi_0, ... , \xi_{n-1} \in \mathbb{K}$ és + \begin{itemize} + \item $ \tau \in D_{\varphi}$ és $ \varphi^{(k)}(\tau) = \xi_k \quad (k = 0...n-1) $ + \end{itemize} + Akkor Kezdeti érték problémáról beszélünk. + + \item[Homogenitás] \hfill \\ + Amennyiben $c(x) = 0$ homogén $n$-edrendű lineáris differenciálegyenletről beszélünk. Tehát homogén és inhomogén egyenletek megoldásainak halmazai: \\ + $ M_h := \{\varphi : I \rightarrow \mathbb{K} : \varphi \in D^n, \ \varphi^{(n)} + \sum\limits_{k=0}^{n-1}a_k\cdot\varphi^{(k)} = 0 \} $ \\ + $ M := \{\varphi : I \rightarrow \mathbb{K} : \varphi \in D^n, \ \varphi^{(n)} + \sum\limits_{k=0}^{n-1}a_k\cdot\varphi^{(k)} = c \} $ \\ + (Itt $M_h \ n$-dimenziós lineáris tér, így valamilyen $ \varphi_1,...,\varphi_n \in M_h$ bázist, más néven alaprendszert alkot.) + \item[Állandó együtthatós eset] \hfill \\ + Ebben az esetben $a_0,...,a_{n-1} \in \R$ + \begin{itemize} + \item Karakterisztikus polinom szerepe \\ + Legyen $P(t) := t^n + \sum\limits_{k=0}^{n-1}a_kt^k \quad (t \in \mathbb{K})$ karakterisztikus polinom és \\ + $ \varphi_\lambda(x) := e^{\lambda x} \quad (x \in \R, \lambda \in \mathbb{K}) $ \\\\ + Ekkor: $ \varphi_\lambda \in M_h \Longleftrightarrow P(\lambda) = 0 $\\ + Sőt ha $ \lambda $ $r$-szeres gyöke $P$-nek, és \\ + $ \varphi_{\lambda,j}(x) := x^je^{\lambda x} \ (j = 0..r-1, x\in\R)$, akkor: + $ \varphi_{\lambda,j} \in M_h \Longleftrightarrow \varphi_{\lambda, j}^{(n)}+\sum\limits_{k=0}^{n-1}a_k\varphi_{\lambda, j}^{(k)} $ \\ + azaz $P(\lambda)^{(j)} = 0 \quad (j = 0..r-1)$ + \item Valós megoldások \\ + Legyen $ \lambda = u+iv \quad (u,v \in \R, v\neq0, i^2 = -1) $ \\ + $ \Rightarrow $ az $ x \mapsto x^je^{ux}cos(vx)$, és $x \mapsto x^je^{ux}sin(vx)$ függvények valós alaprendszert (bázist) alkotnak ($M_h$-ban) + \end{itemize} + \item[Példa: Rezgések] \hfill \\ + Írjuk le egy egyenes mentén, rögzített pont körül rezgőmozgást végző $m$ tömegű tömegpont mozgását, ha ismerjük a megfigyelés kezdetekor elfoglalt helyét és az akkori sebességét! \\ + $ \varphi \in \R \rightarrow \R, \varphi \in D^2$ : kitérés-idő függvény \\ + $ m > 0 $ : tömeg \\ + $ F \in \R \rightarrow \R $ : kitérítő erő \\ + $ \alpha > 0 $ : visszatérítő erő, mely arányos $ \varphi $-vel \\ + $ \beta \geq 0 $ : fékezőerő, mely arányos a sebességgel. \\ + $ \Longrightarrow $ (Newton-féle mozgástörvény alapján):\\ + $ m \cdot \varphi'' = F - \alpha\varphi-\beta\varphi'$\\ + $ \varphi(0) = s_0, \varphi'(0) = s'_0 $\\ + \rule{4cm}{0.2pt} \\ + Másodrendű lineáris differenciál egyenlet (kezdeti érték probléma)\\ + Standard alakba írva: $ \varphi'' + \dfrac{\beta}{m}\varphi' + \dfrac{\alpha}{m}\varphi = \dfrac{F}{m} $ + + Tekintsük kényszerrezgésnek a periodikus külső kényszert, amikor: \\ + $ \dfrac{F(x)}{m} = Asin(\omega x ) \quad [A>0$ (amplitúdó), $ \omega > 0$ (kényszerfrekvencia)] \\ + Ekkor $ \omega_0 := \sqrt{\dfrac{\beta}{m}} $ - saját frekvencia\\ + és $\varphi''(x) + \omega_0^2\varphi(x) = Asin(\omega x) $ \\ + Melynek karakterisztikus polinomja : $ P(t) = t^2+\omega_0^2 \quad (t \in \R) $ \\ + Megoldásai: $ \lambda = \pm \ \omega_0i $ \\ + + Korábban láttuk, hogy ha $ \lambda = u+iv$ akkor $ x \mapsto x^je^{ux}cos(vx)$, és $x \mapsto x^je^{ux}sin(vx)$ függvények valós alaprendszert (bázist) alkotnak ($M_h$-ban). Így $ \varphi(x) = c_1cos(\omega_0x) + c_2sin(\omega_0x) $ alakban írható mely fázisszög segítségével: $ d\cdot sin(\omega_0x+\delta) \quad (d = \sqrt{c_1^2+c_2^2}, \delta \in \R)$ alakra átírható. Így: \\ + $ M_h = \{ d\cdot sin(\omega_0x+\delta)\}$ + + Ekkor már könnyen megadhatunk egy partikuláris megoldást: + \begin{itemize} + \item $\omega \neq \omega_0$ esetén partikuláris megoldás: \\ + $ x \rightarrow q\cdot sin(\omega x) $\\ + És $ q = \dfrac{A}{\omega_0^2-\omega^2} $ kielégíti a $-q\omega^2sin(\omega x)+\omega_0^2q\cdot sin(\omega x) = Asin(\omega x) $ egyenletet. + Tehát: \\ + $ \varphi(x) = d\cdot sin(\omega_0x + \delta)+\dfrac{A}{\omega_0^2-\omega^2}sin(\omega x) $ megoldás két harmonikus rezgés összege. + \item $ \omega = \omega_0 $ (rezonancia) esetén partikuláris megoldás: \\ + $ x \rightarrow qx\cdot cos(\omega x) $\\ + És $ q = \dfrac{-A}{2\omega} $ kielégíti a $-2q\omega \cdot sin(\omega x)- q\omega^2x\cdot cos(\omega x) +\omega^2qx\cdot cos(\omega x) = Asin(\omega x) $ egyenletet. + Tehát: \\ + $ \varphi(x) = d\cdot sin(\omega x + \delta)-\dfrac{A}{2\omega}x\cdot cos(\omega x) $ megoldás egy harmonikus és egy aperiodikus rezgés összege.\\ + (Ebben az esetben az idő (x) elteltével a $\varphi $ értéke nő. Bizonyos modellekben ez a "rendszer szétesését" idézi elő) + \end{itemize} +\end{description} +\end{document} \ No newline at end of file diff --git a/2.Differenciál- és integrálszámítás/img/inflexio_sin.png b/2. Differenciál- és integrálszámítás/img/inflexio_sin.png similarity index 100% rename from 2.Differenciál- és integrálszámítás/img/inflexio_sin.png rename to 2. Differenciál- és integrálszámítás/img/inflexio_sin.png diff --git a/2.Differenciál- és integrálszámítás/img/inflexio_x2.png b/2. Differenciál- és integrálszámítás/img/inflexio_x2.png similarity index 100% rename from 2.Differenciál- és integrálszámítás/img/inflexio_x2.png rename to 2. Differenciál- és integrálszámítás/img/inflexio_x2.png diff --git a/2.Differenciál- és integrálszámítás/img/inflexio_x3.png b/2. Differenciál- és integrálszámítás/img/inflexio_x3.png similarity index 100% rename from 2.Differenciál- és integrálszámítás/img/inflexio_x3.png rename to 2. Differenciál- és integrálszámítás/img/inflexio_x3.png diff --git a/2.Differenciál- és integrálszámítás/img/konvex.png b/2. Differenciál- és integrálszámítás/img/konvex.png similarity index 100% rename from 2.Differenciál- és integrálszámítás/img/konvex.png rename to 2. Differenciál- és integrálszámítás/img/konvex.png diff --git a/20. Adatbázisok tervezése és lekérdezése/20. Adatbázisok tervezése és lekérdezése.pdf b/20. Adatbázisok tervezése és lekérdezése/20. Adatbázisok tervezése és lekérdezése.pdf new file mode 100644 index 0000000..36f4fc3 Binary files /dev/null and b/20. Adatbázisok tervezése és lekérdezése/20. Adatbázisok tervezése és lekérdezése.pdf differ diff --git a/20. Adatbázisok tervezése és lekérdezése/20. Adatbázisok tervezése és lekérdezése.tex b/20. Adatbázisok tervezése és lekérdezése/20. Adatbázisok tervezése és lekérdezése.tex new file mode 100644 index 0000000..1af1434 --- /dev/null +++ b/20. Adatbázisok tervezése és lekérdezése/20. Adatbázisok tervezése és lekérdezése.tex @@ -0,0 +1,508 @@ +\documentclass[margin=0px]{article} + +\usepackage{listings} +\usepackage[utf8]{inputenc} +\usepackage{graphicx} +\usepackage{float} +\usepackage[a4paper, margin=0.7in]{geometry} +\usepackage{amsthm} +\usepackage{amssymb} +\usepackage{fancyhdr} +\usepackage{setspace} + +\onehalfspacing + +\newenvironment{tetel}[1]{\paragraph{#1 \\}}{} + +\pagestyle{fancy} +\lhead{\it{PTI BSc Záróvizsga tételek}} +\rhead{20. Adatbázisok tervezése és lekérdezése} + +\title{\textbf{{\Large ELTE IK - Programtervező Informatikus BSc} \vspace{0.2cm} \\ {\huge Záróvizsga tételek}} \vspace{0.3cm} \\ 20. Adatbázisok tervezése és lekérdezése} +\author{} +\date{} + +\begin{document} +\maketitle + +\begin{tetel}{Adatbázisok tervezése és lekérdezése} + Relációs adatmodell, egyed-kapcsolat modell és átalakítása relációs adatmodellbe. Relációs algebra, SQL. Az SQL procedurális kiterjesztése (PL/SQL vagy PSM). Relációs adatbázis-sémák tervezése, normálformák, dekompozíciók. +\end{tetel} + +\section{Relációs adatmodell, egyed-kapcsolat modell és átalakítása relációs adatmodellbe} + +\subsection{Relációs adatmodell} + +\textit{Relációs adatmodell}: adatok gyűjteményét kezeli. \\ +\textit{Reláció}: a gyűjtemény megadása (tábla). \\ +\textit{Adatmodell}: a valóság fogalmainak, kapcsolatainak, tevékenységeinek magasabb szintű ábrázolása, számítógép és felhasználó számára is megadja, hogy hogyan néznek ki az adatok. Adatok leírására szolgáló jelölés. \\ +\textit{Részei}: +\begin{enumerate} + \item az adat struktúrája + \item az adaton végezhető műveletek + \item az adatokra tett megszorítások +\end{enumerate} + +Egyéb fogalmak: +\begin{itemize} + \item Relációséma: \textit{relációnév(sortípus)}, $R(A_1,...A_n)$ + \item Előfordulás: példány, a sortípusnak megfelelő \textit{véges sok} sor, $\{t_1,...t_m\}$, ahol $t_i = $ + \item Attribútumok: adattípus : sortípus, $<$attr.név$_1$ : értéktípus$_1$,...$>$ + \item Kulcsok: Egyszerű kulcs 1 attribútumból áll, összetett többől, nem lehet a relációban két különböző sor, aminek azonos a kulcsa. + \item Külső kulcs: Idegen kulcs. $R(A_1,...A_m)$ reláció, $X=\{A_{i_1},...A_{i_k}\}$ kulcs. $S(B_1,...B_n)$ reláció, $Y=\{B_{j_1},...B_{j_k}\}$ idegen kulcs, ami az $X$-re hivatkozik a megadott attribútum sorrendben: $B_{j_1}$ az $A_{i_1}$-re stb. + \item Hivatkozási épség: megszorítás a két tábla együttes előfordulására. Ha $s \in S$ sor, akkor $\exists t \in R$ sor: $s[B_{j_1},...B_{j_k}] = t[A_{i_1},...A_{i_k}]$. +\end{itemize} +A relációs adatmodell több szempontból is előnyös, amik miatt elterjedt és kifinomult. Az adatmodell egy egyszerű és könnyen megérthető strukturális részt tartalmaz. A természetes táblázatos formát nem kell magyarázni, és jobban alkalmazható. A relációs modellben a fogalmi-logikai-fizikai szint teljesen szétválik, nagyfokú logikai és fizikai adatfüggetlenség. A felhasználó magas szinten, hozzá közel álló fogalmakkal dolgozik (implementáció rejtve). Elméleti megalapozottság, több absztrakt kezelő nyelv létezik, például relációs algebra (ezen alapul az SQL automatikus és hatékony lekérdezés optimalizálása). Műveleti része egyszerű kezelői felület, szabvány SQL. \\ \\ + +\textit{Relációs adatbázis felépítése}: Az adatbázis tulajdonképpen relációk halmaza. A megfelelő relációsémák halmaza adja az adatbázissémát (jelölése dupla szárú $\mathbb{R}$), $\mathbb{R} = \{R_1 , ... , R_k\}$. A hozzá tartozó előfordulások az adatbázis-előfordulás. Előfordulás tartalma: egyes relációk előfordulásai. Ez a koncepcionális szint, vagyis a fogalmi modell. Fizikai modell: a táblát valamilyen állományszerkezetben jeleníti meg (például szeriális állományban). A relációs adatbázis-kezelők indexelnek, indexelési mód: pl. B+ fa. + +\subsection{Egyed-kapcsolat modell} + +Elemei: +\begin{itemize} + \item Egyedhalmazok: hasonló egyedek összessége + \item Attribútumok: megfigyelhető tulajdonságok, megfigyelt értékek, egyedek tulajdonságai + \item Kapcsolatok: más egyedhalmazokkal való kapcsolatok + \item Séma: $E(A_1,...A_n)$ egyedhalmaz séma, $E$ név, $A_i$ tulajdonság, $DOM(A_i)$ a lehetséges értékek halmaza, pl \textit{tanár(név, tanszék)} + \item Előfordulás: Konkrét egyedek (entitások), $E=\{e_1,...e_m\}, e_i(k) \in DOM(A_k)$ az egyedek halmaza. Minden attribútumban nem egyezhetnek meg $\to$ (vagyis az összes tulajdonság szuperkulcsot alkot), minimális szuperkulcs = kulcs. + \item $K(E_1,E_2)$ bináris kapcsolat, $K(E_1,...E_p)$ a kapcsolat sémája. $K$ a kapcsolat neve, $E_i$ az egyedhalmazok sémái, többágú kapcsolat, ha p>2. pl \textit{tanít(tanár, tárgy)}. Többágú kapcsolat átírható megfelelő számú binér kapcsolatra, 3-ágú 3-ra stb. + \item $K(E_1,...E_p)$ sémájú kapcsolat előfordulása, $K=\{(e_1,...e_p)\}$ egyed p-esek halmaza, ahol $e_i \in E_i$. A kapcsolat előfordulásaira tett megszorítások határozzák meg a kapcsolat típusát. +\end{itemize} +Diagram: egyedhalmazok, kapcsolatok típusok, egyenek ábrázolása. \\ +Szerepek: egyedhalmaz önmagával kapcsolódik \\ +Kapcsolat attribútum: két egyedhalmaz együttes függvénye, de egyiké sem külön \\ +Egyedhalmaz: az elsődleges kulcshoz tartozó tulajdonságokat aláhúzzuk \\ + +\begin{figure}[H] + \centering + \includegraphics[width=0.3\textwidth]{img/ek4.png} + \caption{Szerepek} +\end{figure} + +Kapcsolatok típusai (vegyünk hozzá egy $K(E_1,E_2)$ bináris kapcsolatot alapul): +\begin{itemize} + \item sok-egy: $K$ előfordulásaiban minden $E_1$-beli egyedhez legfeljebb 1 $E_2$-beli tartozhat, pl \textit{született(név,ország)} + \item sok-sok: nincs megszorítása, minden $E_1$-beli egyedhez több $E_2$-beli egyed tartozhat, és fordítva, minden $E_2$-beli egyedhez több $E_1$-beli egyed tartozhat, pl \textit{tanul(diák,nyelv)} + \item egy-egy: sok-egy és egy-sok, vagyis minden $E_1$-beli egyedhez legfeljebb egy $E_2$-beli egyed tartozhat, és fordítva, minden $E_2$-beli egyedhez legfeljebb egy $E_1$-beli egyed tartozhat, pl \textit{házaspár(férfi,nő)} +\end{itemize} +Lehet több kapcsolat is két egyedhalmaz között. \\ +\textit{Alosztály}: ,,isa" = ,,az-egy", öröklődés, speciális egy-egy kapcsolat. Összes $E_1$-belihez van egy $E_2$-beli, pl \textit{isa(főnök, dolgozó)} +\begin{figure}[H] + \centering + \includegraphics[width=0.6\textwidth]{img/ek2.png} + \caption{Alosztály} +\end{figure} +\textit{Kulcs}: aláhúzással jelölik, összetett kulcsnál több attribútum van aláhúzva \\ +\textit{Szuperkulcs}: Az egyedhalmaz szuperkulcsa egy azonosító, vagyis olyan tulajdonság-halmaz, amelyről feltehető, hogy az egyedhalmaz előfordulásaiban nem szerepel két különböző egyed, amelyek ezeken a tulajdonságokon megegyeznek. Az összes tulajdonság mindig szuperkulcs.\\ +\textit{Hivatkozási épség}: kerek végződéssel jelölik, megszorítás +\begin{figure}[H] + \centering + \includegraphics[width=0.6\textwidth]{img/ek3.png} + \caption{Hivatkozási épség} +\end{figure} +\textit{Gyenge egyedhalmaz}: Téglalap dupla kontúrral. Önmagában nem azonosítható egyértelműen. +\begin{figure}[H] + \centering + \includegraphics[width=0.45\textwidth]{img/ek5.png} + \includegraphics[width=0.45\textwidth]{img/ek6.png} + \caption{Gyenge egyedhalmaz} +\end{figure} +Tervezési alapelvek: +\begin{itemize} + \item valósághű modellezés: megfelelő tulajdonságok tartozzanak az egyedosztályokhoz, például a tanár neve ne a diák tulajdonságai közé tartozzon + \item redundancia elkerülése: az \textit{index(etr-kód,lakcím,tárgy,dátum,jegy)} rossz séma, + mert a lakcím annyiszor ismétlődik, ahány vizsgajegye van a diáknak, helyette 2 sémát érdemes felvenni: \textit{hallgató(etr-kód,lakcím)}, \textit{vizsga(etr-kód,tárgy,dátum,jegy)}. + \item egyszerűség: fölöslegesen ne vegyünk fel egyedosztályokat, például a \textit{naptár(év,hónap,nap)} helyett a megfelelő helyen inkább dátum tulajdonságot használjunk + \item tulajdonság vagy egyedosztály: például a vizsgajegy osztály helyett jegy tulajdonságot + használjunk. +\end{itemize} + +\subsection{Egyed-kapcsolat modell átalakítása relációs adatmodellbe} + +\begin{figure}[H] + \centering + \includegraphics[width=0.6\textwidth]{img/ek7.png} + \caption{Példa: könyvtár adatmodellje} +\end{figure} +\textit{Összetett attribútumok leképezése}: például ha a lakcímet (helység, utca, házszám) struktúrában akarjuk kezelni, akkor fel kell venni a sémába mindet attribútumként. +\textit{Többértékű attribútumok leképezése}: +\begin{itemize} + \item Megadás egyértékűként. Példa: többszerzős könyvnél egy mezőben soroljuk fel az összeset. Nem túl jó, mert nem lehet a szerzőket külön kezelni, és esetleg nem is fér el mind a mezőben. + \item Megadás többértékűként. + \begin{itemize} + \item Sorok többszörözése. Könyves példánál maradva, felveszünk annyi sort, ahány szerző van. Ez redundanciához vezet. + \item Új tábla felvétele. A \textit{könyv(könyvszám, szerző, cím)} sémát az alábbi két sémával helyettesítjük: \textit{könyv(\underline{könyvszám}, cím)}, \textit{szerző(\underline{könyvszám}, \underline{szerző})} + \item Sorszámozás. Ha nem mindegy a szerzők sorrendje, akkor az előző megoldásban (új tábla) ki kell egészíteni a szerző táblát egy sorszám mezővel. + \end{itemize} +\end{itemize} +\textit{Kapcsolatok leképezése}: +\begin{itemize} + \item egy-egy: beolvasztás az azonos kulcsú sémába. Pl egy könyvet lehet kölcsönözni: KÖLCSÖN(\underline{könyvszám}, olvasószám, \textbf{kivétel}) kapcsolatsémából KÖNYV (\underline{könyvszám}, szerző, cím, olvasószám, \textbf{kivétel}), OLVASÓ (\underline{olvasószám}, név, lakcím) lesz. Itt a kapcsolatsémában az olvasószám is kulcs, és felvehetnénk úgy is, hogy az legyen a kulcs. Ez esetben az OLVASÓ-ba kell beolvasztani. + \item sok-egy: beolvasztás a ,,sok"-ba. Tehát a példát követve, ha több könyvet lehet kölcsönözni, akkor a könyvszámnak kell a kulcsnak lennie, és csak a KÖNYV-be olvaszthatjuk be. + \item sok-sok: új tábla. Ha a korábbi kölcsönzések is el vannak tárolva, akkor a kulcsban benne van vagy a kivétel, vagy a visszahozás. Ekkor egyik táblába sem lehet beolvasztani, új táblát kell létrehozni. A séma ez lehet: KÖNYV (\underline{könyvszám}, szerző, cím), OLVASÓ (\underline{olvasószám}, név, lakcím), KÖLCSÖN (\underline{könyvszám}, olvasószám, \underline{kivétel}, visszahozás). +\end{itemize} + +\textit{Átalakítás} E/K modell $\to$ relációs adatmodell: +\begin{itemize} + \item egyedhalmaz séma $\to$ relációséma + \item tulajdonságok $\to$ attribútumok + \item (szuper)kulcs $\to$ (szuper)kulcs + \item egyedhalmaz előfordulása $\to$ reláció + \item egyed $\to$ $e(A_1)...e(A_n)$ sor + \item $R(E_1,...E_p, A_1,...A_q)$ kapcsolati séma ($E_i$ egyedhalmaz, $A_j$ tulajdonság) $\to$ $R(K_1,...K_p, A_1,...A_q)$ relációséma ($K_i$ az $E_i$ (szuper)kulcsa) +\end{itemize} +Átnevezhetjük, hogy ne legyen kétszer ugyanaz. \\ +isa esetén a speciális osztályhoz hozzávesszük az általános osztály (szuper)kulcsát. Gyenge entitáshoz a meghatározó kapcsolatok kulcsait vesszük hozzá. \\ +\textit{Összevonás} akkor lehet, ha az egyikben idegenkulcs van a másikra. Illetve akkor, ha sok-egy kapcsolatnak felel meg az egyik reláció, a másik pedig a sok oldalon álló egyedhalmaz reláció. Pl Ivók(név, cím) és Kedvenc(ivó,sör) összevonható, és kapjuk az Ivó1(név,cím,kedvencSöre) sémát. \\ +\begin{figure}[H] + \centering + \includegraphics[width=0.6\textwidth]{img/ek8.png} + \caption{Gyenge egyedhalmaz átírása} +\end{figure} +\begin{figure}[H] + \centering + \includegraphics[width=0.6\textwidth]{img/ek9.png} + \caption{Példa alosztály átírására relációkká} +\end{figure} +\textit{Alosztály átírása}: +\begin{itemize} + \item Egyed-kapcsolatos: modellben legyen 1 reláció minden alosztályra, de az általánosból csak a kulcsokat vesszük hozzá a saját attribútumokhoz.\\ + Minden altípushoz külön tábla, egy egyed több táblában is szerepelhet. Főtípus táblájában minden egyed szerepel, plusz annyi altípuséban, amennyiben szerepel. Hátrány: több táblában keresés. + \begin{figure}[H] + \centering + \includegraphics[width=0.6\textwidth]{img/ek.png} + \caption{E/K stílusú} + \end{figure} + \item Nullértékes: 1 reláció van összesen, ha nincs a speciális tulajdonság, akkor NULL-t írunk a helyére.\\ + Attribútumok uniója szerepel a táblában. Hátrány, hogy sok NULL van a táblában, típusinformációt is elveszíthetünk (például ha a gépteremnél a gépszám nem ismert, és ezért NULL, akkor a gépterem lényegében az egyéb helyiségek kategóriájába kerül). + \begin{figure}[H] + \centering + \includegraphics[width=0.6\textwidth]{img/null.png} + \caption{NULL értékes} + \end{figure} + \item Objektumorientált: 1 reláció minden alosztályra, összes tulajdonság felsorolva az örököltből is. \\ + Minden altípushoz külön tábla, egy egyed csak 1 táblában szerepel. Hátrányok: kombinált altípushoz új altípus felvétele szükséges, keresés gyakran több táblán keresztül. + \begin{figure}[H] + \centering + \includegraphics[width=0.6\textwidth]{img/oo.png} + \caption{Objektumorientált} + \end{figure} +\end{itemize} + +\section{Relációs algebra, SQL} + +\subsection{Relációs algebra} + +Algebra műveleteket és atomi operandusokat tartalmaz. \\ +\textit{Relációs algebra}: az atomi operandusokon és az algebrai kifejezéseken végzett műveletek alkalmazásával kapott relációkon műveleteket adunk meg, kifejezéseket építünk (a kifejezés felel meg a kérdés szintaktikai alakjának). Fontos tehát, hogy minden művelet végeredménye reláció, amelyen további műveletek adhatók meg. A relációs algebra atomi operandusai a következők: a relációkhoz tartozó változók; konstansok, amelyek véges relációt fejeznek ki. +\textit{Műveletek}: +\begin{itemize} + \item Halmazműveletek: Reláció előfordulás véges sok sorból álló halmaz. Így értelmezhetők a szokásos halmazműveletek: az unió (az eredmény halmaz, csak egyszer szerepel egy sor), értelmezhető a metszet és a különbség. \\ + R, S azonos típusú, R $\cup$ S és R $-$ S típusa ugyanez \\ + Az alapműveletekhez az unió és különbség tartozik, metszet műveletet származtatjuk: $R \cap S = R - (R - S)$ + \item Vetítés (projekció): Adott relációt vetít le az alsó indexben szereplő attribútumokra (attribútumok számát csökkentik). $\Pi_{lista}(R)$, ahol $\{A_{i_1},...A_{i_k}\}$ R sémájában levő attribútumok egy részhalmazának felsorolása. Reláció soraiból kiválasztja az attribútumoknak megfelelő $A_{i_1},...A_{i_k}$-n előforduló értékeket, ha többször előfordul, akkor a duplikátumokat kiszűrjük (hogy halmazt kapjunk). + \item Kiválasztás (szűrés): Kiválasztja az argumentumban szereplő reláció azon sorait, amelyek eleget tesznek az alsó indexben szereplő feltételnek. $\sigma_F(R) = \{t|t \in R$ és $t$ kielégíti az $F$ feltételt$\}$ \\ + A feltétel lehet elemi vagy összetett. Elemi: $A_i \Theta A_j$, $A_i \Theta c$, ahol $c$ konstans, $\Theta$ pedig $=, \neq, <, >, \geq, \leq$. Összetett: ha $B_1, B_2$ feltétel, akkor $\not B_1, B_1 \cap B_2, B_1 \cup B_2$ és a zárójelezések is feltétel. + \item Természetes összekapcsolás: Szorzásjellegű műveletek közül csak ez az alapművelet. Nő az attribútumok száma. A közös attribútumnevekre épül. $R \bowtie S$ azon sorpárokat tartalmazza R-ből illetve S-ből, amelyek R és S azonos attribútumain megegyeznek. $R \bowtie S$ típusa a két attribútumhalmaz uniója. + \item Átnevezés: Reláció önmagával vett szorzatát ki tudjuk fejezni vele. $\rho_{T(B_1,...B_k)}(R(A_1,...A_k))$, ha az attribútumokat nem akarjuk átnevezni, akkor $\rho_{T}(R)$ +\end{itemize} +A relációs algebrában a fent felsorolt 6 alapművelet van. Ez egy \textit{minimális készlet}, vagyis bármelyiket elhagyva az a többivel nem fejezhető ki. \\ +Szorzásjellegű műveletnél tekinthetjük a \textit{direkt-szorzatot} alapműveletnek, de a természetes összekapcsolást használják. $R \times S$: az R és S minden sora párban összefűződik, az első tábla minden sorához hozzáfűzzük a második tábla minden sorát. A direkt-szorzat (vagy szorzat, Descartes-szorzat) esetén természetesen nem fontos az attribútumok egyenlősége. A két vagy több reláció azonos nevű attribútumait azonban meg kell különböztetni egymástól (átnevezéssel). \\ +\textit{Monotonitás}: monoton, nem csökkenő kifejezés esetén bővebb relációra alkalmazva az eredmény is bővebb.\\ +A kivonás kivételnek számít az alapműveletek között, mert nem monoton. Következmény ebből, hogy a kivonás nem fejezhető ki a többi alapművelettel. A kivonás nélkül szokás monoton relációs algebrának is nevezni. \\ +\textit{Osztás}: maradékos osztás mintájára. R és S sémája $R(A_1,...,A_n,B_1,...,B_m)$, illetve $S(B_1,...,B_m)$, $Q = R \div S$ sémája $Q(A_1,...,A_n)$. $R \div S$ a legnagyobb (legtöbb sort tartalmazó) reláció, amelyre $( R \div S ) \times S \subseteq R.$ Relációs algebrában: $R(A,B) \div S(B) = \Pi_{A_1,...,A_n}(R) – \Pi_{A_1,...,A_n}( \Pi_{A_1,...,A_n}(R) \times S – R )$\\ +Relációs algebrai kifejezés, mint lekérdező nyelv (L-nyelv). Az alapkifejezések az elemi kifejezések, az összetettek pedig a rajtuk végzett alapműveletek. \\ +\textit{Kifejezés kiértékelése}: összetett kifejezést kívülről befelé haladva átírjuk kiértékelő fává, levelek: elemi kifejezések. +\begin{figure}[H] + \centering + \includegraphics[width=0.6\textwidth]{img/relalg1.png} + \caption{Kifejezésfa} +\end{figure} + +\subsubsection{Relációs algebra kiterjesztése} + +\begin{itemize} + \item Ismétlődések megszüntetése ($\delta$), select distinct. Multihalmazból halmazt csinál. + \item Összesítő műveletek és csoportosítás ($\gamma_{lista}$), group by. Összesítő függvények: sum, count, min, max, avg. Itt a $lista$ valamennyi eleme a következők egyike: + \begin{itemize} + \item a reláció egy attribútuma: ez az attribútum egyike a csoportosító attribútumoknak (a GROUP BY után jelenik meg). + \item a reláció egyik attribútumára (ez az összesítési attribútumra) alkalmazott összesítő operátor, ha az összesítés eredményére névvel szeretnénk hivatkozni, akkor nyilat és új nevet használunk. + \end{itemize} + R sorait csoportokba osszuk. Egy csoport azokat a sorokat tartalmazza, amelyek a listán szereplő + csoportosítási attribútumokhoz tartozó értékei megegyeznek, vagyis ezen attribútumok minden egyes különböző értéke egy csoportot alkot. Minden egyes csoporthoz számoljuk ki a lista összesítési attribútumaira vonatkozó összesítéseket. Az eredmény minden egyes csoportra egy sor: + \begin{enumerate} + \item a csoportosítási attribútumok és + \item Az összesítési attribútumra vonatkozó összesítése (az adott csoport összes sorára) + \end{enumerate} + \item Vetítési művelet kiterjesztése ($\Pi_{lista}$), select kif [as onev]. A $lista$ tartalmazhatja: + \begin{itemize} + \item R egy attribútumát, + \item x $\to$ y, ahol x, y attribútumnevek, s itt x-et y-ra nevezzük át, + \item E $\to$ y, ahol E R attribútumait, konstansokat, aritmetikai operátorokat és karakterlánc operátorokat tartalmazhat, például: A + 5, C $||$ 'nevű emberek'. + \end{itemize} + \item Rendezési művelet ($\tau_{lista}$), order by. $lista = (A_1,...A_n)$ Először $A_1$ attribútum szerint rendezzük R sorait. Majd azokat a sorokat, amelyek értéke megegyezik az $A_1$ attribútumon, $A_2$ szerint, és így tovább. \\ + Ez az egyetlen olyan művelet, amelynek az eredménye se nem halmaz, se nem multihalmaz. + \item Külső összekapcsolások ($\mathring{\bowtie}$), [left $|$ right $|$ full] outer join. Ez nem relációs algebrai művelet, ugyanis kilép a modellből. $R \bowtie S$ relációt kiegészítjük az R és S soraival, a hiányzó helyekre NULL értéket írva megőrzi a ,,lógó sorokat". +\end{itemize} +SQL-ben, és a kiterjesztésben is multihalmazok vannak, vagyis egy sor többször is előfordulhat. \\ +R és S uniójánál n+m előfordulás lesz, metszeténél min[n,m], különbségnél max[0, n-m]. A többi műveletnél nem küszöböljük ki az ismétlődéseket. + +\subsection{SQL} + +Fő komponensei: +\begin{itemize} + \item Adatleíró nyelv, DDL (Data Definition Language): CREATE, ALTER, DROP + \item Adatkezelő nyelv, DML (Data Manipulation Language): INSERT, UPDATE, DELETE, SELECT \\ + Az SQL elsődlegesen lekérdező nyelv (Query Language): SELECT utasítás (az adatbázisból információhoz jussunk) + \item Adatvezérlő nyelv, DCL (Data Control Language): GRANT, REVOKE + \item Tranzakció-kezelés: COMMIT, ROLLBACK, SAVEPOINT + \item Procedurális kiterjesztések: Oracle PL/SQL (Ada alapján), SQL/PSM (PL/SQL alapján) +\end{itemize} +Reláció itt tábla, alapvetően 3-féle: TABLE (alaptábla, permanens), VIEW (nézettábla), WITH utasítással (átmeneti munkatábla).\\ +Séma megadása CREATE utasítással, típus SQL konkrét megvalósítása alapján. Kiegészítő lehetőségek is vannak, pl PRIMARY KEY. Csak egyetlen PRIMARY KEY lehet a relációban, viszont UNIQUE több is lehet, PRIMARY KEY egyik attribútuma sem lehet NULL érték egyik sorban sem. Viszont UNIQUE-nak deklarált attribútum lehet NULL értékű, vagyis a táblának lehet olyan sora, ahol a UNIQUE attribútum értéke NULL, vagyis hiányzó érték. \\ \\ + +Relációs algebrai kifejezések felírása SELECT-tel: +\begin{itemize} + \item SELECT lista FROM táblák szorzata WHERE felt. = $\Pi_{lista}(\sigma_{felt.}$(táblák szorzata)) + \item halmazműveletek: UNION, EXCEPT/MINUS, INTERSECT. Multihalmazból halmaz lesz. ALL kulcsszóval megmarad a multihalmaz. + \item átnevezés: oszlopnév után szóközzel odaírjuk az új nevet. +\end{itemize} +Kiterjesztett műveletek: +\begin{itemize} + \item rendezés: ORDER BY, minden más záradék után következik, csökkenő, növekvő sorrend. + \item ismétlődések megszüntetése: select DISTINCT ... + \item összesítések (aggregálás): SUM, COUNT, MIN, MAX, AVG a SELECT záradékban. COUNT(*) az eredmény sorainak száma. Ha összesítés is szerepel a lekérdezésben, a SELECT-ben felsorolt attribútumok vagy egy összesítő függvény paramétereként szerepelnek, vagy a GROUP BY attribútumlistájában is megjelennek. + \item csoportosítás: GROUP BY. + \item csoportok szűrése: HAVING. Csoportokat szűr, nem egy-egy sort. Az alkérdésre nincs megszorítás. Viszont az alkérdésen kívül csak olyan attribútumok szerepelhetnek, amelyek: vagy csoportosító attribútumok, vagy összesített attribútomok. (Azaz ugyanazok a szabályok érvényesek, mint a SELECT záradéknál). +\end{itemize} +\begin{figure}[H] + \centering + \includegraphics[width=0.6\textwidth]{img/sql2.png} + \caption{Példa csoportosításra} +\end{figure} +WHERE záradéknál SQL-es specialitások: +\begin{itemize} + \item Átírható relációs algebrába: BETWEEN ... AND ..., IN(értékhalmaz) + \item Nem írható át: LIKE karakterláncok összehasonlításánál, IS NULL (ismeretlen vagy nem definiált érték) [emiatt 3-értékű logika SQL-ben: true, false, unknown] +\end{itemize} +SELECT utasítás több részből áll, a részeket záradékoknak nevezzük. Három alapvető záradék van: +\begin{itemize} + \item SELECT lista (3.) -- milyen típusú sort szeretnénk az eredményben látni? * jelentése: minden attribútum. + \item FROM Relációnév (1.) -- a tábla neve vagy relációk (táblák) összekapcsolása, illetve szorzata + \item WHERE feltétel (2.) -- milyen feltételeknek eleget tevő sorokat kiválasztani? +\end{itemize} +Több séma összekapcsolása esetén ha egy attribútumnév több sémában is előfordul, akkor kell hozzá a séma is a hivatkozásnál: R.A (R reláció A attribútuma). \\ +\textit{Alkérdéseket} is használhatunk SQL-ben, ezt zárójelbe tevéssel érjük el.\\ +\begin{itemize} + \item FROM záradékban ilyen módon ideiglenes táblát is létrehozhatunk, ekkor többnyire a sorváltozó nevét is meg kell adni hozzá. + \item WHERE záradékban az alkérdés eredménye lehet: + \begin{itemize} + \item egy skalárérték, vagyis mintha egy konstans lenne + \item skalár értékekből álló multihalmaz, logikai kifejezésekben használható: EXISTS, [NOT] IN, ANY/ALL (pl x > ANY (alkérdés)). + \item teljes többdimenziós tábla, használható: EXISTS, [NOT] IN + \end{itemize} +\end{itemize} +Az alkérdés nem korrelált, ha önállóan kiértékelhető, külső kérdés közben nem változik. Korrelált, ha többször kerül kiértékelésre, alkérdésen kívüli sorváltozóból származó értékadással. +\begin{figure}[H] + \centering + \includegraphics[width=0.45\textwidth]{img/sql1.png} + \caption{SQL záradékok} +\end{figure} +\textit{Összekapcsolások}: +\begin{itemize} + \item Descartes-szorzat: R CROSS JOIN S, vagy ,,R,S" + \item Természetes összekapcsolás: R NATURAL JOIN S + \item Théta-összekapcsolás: R JOIN S ON + \item Külső összekapcsolás: R $\{$LEFT $|$ RIGHT $|$ FULL$\}$ OUTER JOIN S. LEFT az R lógó sorait őrzi meg, RIGHT az S-ét, FULL az összeset. +\end{itemize} + +\subsubsection{DML} + +A módosító utasítások nem adnak vissza eredményt, mint a lekérdezések, hanem az adatbázis tartalmát változtatják meg. 3-féle módosító utasítás létezik: +\begin{itemize} + \item INSERT - sorok beillesztése, beszúrása. Egyetlen sor: INSERT INTO R VALUES ($<$attr. lista$>$). A tábla létrehozásánál ha megadtunk default értékeket attribútumoknál, akkor ha nem adunk meg értéket hozzá, akkor a default lesz, egyébként NULL. Több sor: INSERT INTO R ($<$alkérdés$>$). + \item DELETE – sorok törlése. DELETE FROM R [WHERE $<$feltétel$>$]. + \item UPDATE – sorok komponensei értékeinek módosítása. UPDATE R SET $<$attribútum értékadások listája$>$ WHERE $<$sorokra vonatkozó feltétel$>$ +\end{itemize} +\textit{Tranzakciók}: Az adatbázisrendszereket általában több felhasználó és folyamat használja egy időben. Tranzakció = olyan folyamat, ami adatbázis lekérdezéseket, módosításokat tartalmaz. Az utasítások egy ,,értelmes egészt" alkotnak. \\ +ACID: atomicity (vagy az összes vagy egyik utasítás sem hajtódik végre), consistency (konzisztencia, a megszorítások megőrződnek), isolation (elkülönítés, felhasználó számára úgy tűnik, hogy egymás után futnak a tranzakciók), durability (tartósság, befejeződött tranzakció módosításai nem vesznek el). \\ +A COMMIT SQL utasítás végrehajtása után a tranzakció véglegesnek tekinthető. A tranzakció módosításai véglegesítődnek. A ROLLBACK SQL utasítás esetén a tranzakció abortál, azaz az összes utasítás visszagörgetésre kerül. \\ +Többféle elkülönítési szint közül lehet választani, hogy az egy időben történő tranzakciók esetén milyen interakciók engedélyezettek. +\begin{enumerate} + \item SERIALIZABLE: ACID tulajdonságok teljesülnek rá. Más tranzakciója közbeni állapotot nem láthat a felhasználó. + \item REPEATABLE READ: Hasonló a read-commited megszorításhoz. Itt, ha az adatot újra beolvassuk, akkor amit először láttunk, másodszor is látni fogjuk. De második és az azt követő beolvasások után akár több sort is láthatunk. + \item READ COMMITTED: csak kommitálás utáni adatot láthat, de nem feltétlenül mindig ugyanazt az adatot. + \item READ UNCOMMITTED +\end{enumerate} + +\subsubsection{DDL} + +Adatleíró részt is tartalmaz az SQL. +\begin{itemize} + \item CREATE: létrehozás + \item DROP: eldobja a teljes leírást, és minden, ami ehhez kapcsolódott, elérhetetlen lesz. + \item ALTER: leírás módosítása +\end{itemize} +A \textit{megszorítás} adatelemek közötti kapcsolat, amelyet az AB rendszernek fent kell tartania. Lehet kulcs megszorítás, értékekre, sorokra vonatkozó. Megszorítás módosítása CONSTRAINTS kulcsszóval, önálló megszorítások: CREATE ASSERTION $<$név$>$ CHECK ($<$feltétel$>$). Itt alapvetően az adatbázis bármely módosítása előtt ellenőrizni kell. Egy okos rendszer felismeri, hogy mely változtatások, mely megszorításokat érinthetnek. \\ +Idegen kulcs (R-ről S-re) megszorítást meg kell őrizni, ez kétféleképpen sérülhet: 1. Egy R-be történő beszúrásnál vagy R-ben történő módosításnál S-ben nem szereplő értéket adunk meg. 2. Egy S-beli törlés vagy módosítás ,,lógó" sorokat eredményez R-ben. Védeni többféleképpen lehet: alapértelmezetten nem hajtja végre, továbbgyűrűzésnél igazítjuk a tábla értékeit a változáshoz, set NULL-nál pedig az érintett sorokat NULL-ra állítjuk. \\ +Sor megszorításnál a CREATE utasításon belül a végére tehetünk egy CHECK ($<$feltétel$>$) utasítást. \\ \\ +\textit{Triggerek} olyankor hajtódnak végre, amikor valamilyen megadott esemény történik, mint például sorok beszúrása egy táblába. Az önálló megszorításokkal (assertions) sok mindent le tudunk írni, az ellenőrzésük azonban gondot jelenthet. Az attribútumokra és sorokra vonatkozó megszorítások ellenőrzése egyszerűbb (tudjuk mikor történik), ám ezekkel nem tudunk minden kifejezni. A triggerek esetén a felhasználó mondja meg, hogy egy megszorítás mikor kerüljön ellenőrzésre. A triggereket esetenként ECA szabályoknak (event-condition-action) is nevezik. +\begin{itemize} + \item Esemény: általában valamilyen módosítás a adatbázisban, INSERT, DELETE, UPDATE. Mikor?: BEFORE, AFTER, INSTEAD, Mit?: OLD ROW, NEW ROW, FOR EACH ROW, OLD/NEW TABLE, FOR EACH STATEMENT + \item WHEN feltétel : bármilyen SQL igaz-hamis-(ismeretlen) feltétel. + \item Tevékenység : SQL utasítás, BEGIN..END, PSM tárolt eljárás +\end{itemize} +A triggerek az eddigi megszorításoktól három dologban térnek el: +\begin{itemize} + \item A triggereket a rendszer csak akkor ellenőrzi, ha bizonyos események bekövetkeznek. A megengedett események általában egy adott relációra vonatkozó beszúrás, törlés, módosítás, vagy a tranzakció befejeződése. + \item A kiváltó esemény azonnali megakadályozása helyett a trigger először egy feltételt vizsgál meg. + \item Ha a trigger feltétele teljesül, akkor a rendszer végrehajtja a triggerhez tartozó tevékenységet. Ez a művelet ezután megakadályozhatja a kiváltó esemény megtörténtét, vagy meg nem történtté teheti azt. +\end{itemize} +\textit{Nézettáblák}: A nézettábla olyan reláció, amit tárolt táblák (alaptáblák) és más nézettáblák felhasználásával definiálunk. Kétféle létezik: 1. virtuális = nem tárolódik az adatbázisban; csak a relációt megadó lekérdezés. 2. Materializált = kiszámítódik, majd tárolásra +kerül. CREATE [MATERIALIZED] VIEW $<$név$>$ AS $<$lekérdezés$>$. A nézettáblák ugyanúgy kérdezhetők le, mint az alaptáblák. A nézettáblákon keresztül az alaptáblák néhány esetben módosíthatóak is, ha a rendszer a módosításokat át tudja vezetni. Virtuális nézetet nem lehet módosítani, mert nem létezik, de egy INSTEAD OF triggerrel mégis végrehajtathatjuk a változtatásokat. + +\section{Az SQL procedurális kiterjesztése (PL/SQL vagy PSM)} + +\subsection{PSM} + +Amikor az SQL utasításokat egy alkalmazás részeként, programban használjuk, a következő problémák léphetnek fel: +\begin{itemize} + \item Osztott változók használata: közös változók a nyelv és az SQL utasítás között (ott használható SQL utasításban, ahol kifejezés használható). + \item A típuseltérés problémája: Az SQL magját a relációs adatmodell képezi. Tábla – gyűjtemény, sorok multihalmaza, mint adattípus nem fordul elő a magasszintű nyelvekben. A lekérdezés eredménye hogyan használható fel? Három esetet különböztetünk meg attól függően, hogy a SELECT FROM [WHERE stb] lekérdezés eredménye skalárértékkel, egyetlen sorral vagy egy listával (multihalmazzal) tér-e vissza. Utóbbinál kurzor használata, az eredmény soronkénti bejárása. Egyetlen sornál SELECT $e_1,...e_n$ INTO vált$_1$,...vált$_n$ +\end{itemize} +Háromféleképpen is megközelíthetjük programozási szempontból: +\begin{enumerate} + \item SQL kiterjesztése procedurális eszközökkel, az adatbázis séma részeként tárolt kódrészekkel, tárolt modulokkal (pl. PSM = Persistent Stored Modules, Oracle PL/SQL). + \item Beágyazott SQL (sajátos előzetes beágyazás EXEC SQL. - Előfordító alakítja át a befogadó gazdanyelvre/host language, pl. C) + \item Hívásszintű felület: hagyományos nyelvben programozunk, függvénykönyvtárat használunk az adatbázishoz való hozzáféréshez (pl. CLI = call-level interface, JDBC, PHP/DB) +\end{enumerate} +PSM: Persistent Stored Procedures. SQL utasítások és konvencionális elemek (if, while stb) keverékéből áll. Olyan dolgokat is meg lehet csinálni, amit önmagában az SQL-ben nem. +\begin{figure}[H] + \centering + \includegraphics[width=0.45\textwidth]{img/psm1.png} + \includegraphics[width=0.45\textwidth]{img/psm2.png} + \caption{PSM tárolt eljárás és függvény szerkezete} +\end{figure} +A tárolt eljárásnak adhatunk paramétereket is, ezek IN, OUT és INOUT módúak lehetnek. Ezek mellé még a paraméter nevét és típusát is meg kell adni, mód-név-típus hármas. Tárolt függvények esetén csak IN módú paramétereink lehetnek. \\ +Néhány fontosabb utasítás: +\begin{itemize} + \item Eljárás meghívása a CALL $<$eljárás neve$>$ ($<$argumentumlista$>$) utasítással történik. + \item Függvénynél a RETURN utasítás határozza meg a visszatérési érték típusát. Fontos, hogy ezen utasítás hatására nem terminál a függvény. + \item Változót deklarálásához ezt használjuk: DECLARE $<$név$>$ $<$típus$>$. + \item értékadás: SET $<$változó$>$ = $<$kifejezés$>$. + \item BEGIN...END között vannak az utasítások, pontosvesszővel választjuk el őket. + \item címke: utasításnak lehet adni, név és kettőspont elé írásával. + \item SQL utasítások, DML, MERGE. + \item ciklusból kilépés: LEAVE $<$ciklus címkéje$>$ + \item WHILE-DO cikluson kívül REPEAT-UNTIL +\end{itemize} +\textit{Kivételek}: 5 jegyű SQLSTATE karakterlánccal jelzi. Nem mindig hiba, hanem lehet a normálistól eltérő viselkedés is. DECLARE $<$hova menjen$>$ HANDLER FOR $<$feltétel lista$>$ $<$utasítás$>$. A $<$hova menjen$>$ lehet CONTINUE, EXIT, UNDO. \\ +\textit{Kurzorok}: Ha a SELECT eredménye több sorral tér vissza, akkor valamilyen ciklussal járjuk be az eredmény sorait. A kurzor alapvetően egy tuple-változó, ami végigmegy egy lekérdezés eredményének minden tuple-én. DECLARE $<$sormutató$>$ CURSOR FOR ($<$lekérdezés$>$); A kurzor használatához szükség van az OPEN $<$sormutató$>$; utasításra, aminek hatására a rendszer a lekérdezést kiértékeli, és hozzáférhető lesz a lekérdezés eredménye, ehhez a bejáráshoz egy ciklust kell indítani, és a sormutató az eredmény első sorára mutat. Amikor végeztünk, a CLOSE $<$sormutató$>$; utasítással bezárjuk a kurzort. +\begin{figure}[H] + \centering + \includegraphics[width=0.45\textwidth]{img/psm3.png} + \caption{PSM kurzor ciklusának szerkezete} +\end{figure} +A ciklusból való kilépés trükkös pontja a kurzornak. A megoldás a következő: deklarálunk egy boolean feltételt, ami akkor igaz, ha az SQLSTATE egy meghatározott értéket vesz fel (02000, nem talált következő tuple-t). + + +\subsection{PL/SQL} + +PL/SQL-ben nem csak tárolni lehet eljárásokat és függvényeket, hanem futtatni is lehet a ,,generic query interface"-ből (sqlplus), mint bármely SQL utasítást. A triggerek a PL/SQL része. \\ +A deklarációs rész külön válik a törzstől és opcionális, és a DECLARE kulcsszó csak egyszer szerepel a rész elején, nincs minden változó előtt. Értékadás := jellel. További különbség a PSM-hez képest, hogy paramétereknél név-mód-típus sorrendben kell megadni, és az IN OUT mód két szóban írandó. Több új típus is van, pl NUMBER lehet INT van REAL. Egy attribútum típusára lehet hivatkozni is: R.x\%TYPE. Létezik R\%ROWTYPE is, ami egy tuple-t ad vissza. Az x tuple komponensének értékét így kapjuk meg: x.a. ELSEIF (PSM-ben) helyett ELSIF. LEAVE ciklus helyett EXIT WHEN $<$feltétel$>$. +\begin{figure}[H] + \centering + \includegraphics[width=0.45\textwidth]{img/plsql1.png} + \caption{PL/SQL eljárás szerkezete} +\end{figure} +\textit{Kurzor}: CURSOR $<$név$>$ IS $<$lekérdezés$>$. A ciklusban a kurzor tuple-jének lekérése: FETCH $<$kurzor neve$>$ INTO $<$változó(k)$>$. PL/SQL-nél a kurzor ciklusát így hagyjuk el: EXIT WHEN $<$kurzornév$>$\%NOTFOUND. +\section{Relációs adatbázis-sémák tervezése, normálformák, dekompozíciók} + +\subsection{Relációs adatbázis-sémák tervezése} + +Függőségek: funkcionális, többértékű, ezeket a tervezésnél használják (az adatbázisrendszerek nem támogatják, ott megszorítások vannak). \\ +Normalizálás: jó sémákra való felbontás, funkcionális függőségek $\to$ (1,2,)3NF, BCNF; többértékű függőségek $\to$ 4NF. + +\subsubsection{Funkcionális függőségek} + +X $\to$ Y az R relációra vonatkozó megszorítás, miszerint ha két sor megegyezik X összes attribútumán, Y attribútumain is meg kell, hogy egyezzenek. \\ +Jelölés: X, Y, Z... attribútum halmazokat; A, B, C... attribútumokat jelöl. {A,B,C} attribútumhalmaz helyett ABC-t írunk. \\ +\textit{Definíció.} Legyen R(U) egy relációséma, továbbá X és Y az U attribútumhalmaz részhalmazai. X-től \textit{funkcionálisan függ} Y (jelölésben X $\to$ Y), ha bármely R feletti T tábla esetén valahányszor két sor megegyezik X-en, akkor megegyezik Y-on is, $\forall t_1, t_2 \in T$ esetén $(t_1[X]=t_2[X] \Rightarrow t_1[Y]=t_2[Y])$. Ez lényegében azt jelenti, hogy az X-beli attribútumok értéke egyértelműen meghatározza az Y-beli attribútumok értékét. Jelölés: R $\models$ X $\to$ Y, vagyis +R kielégíti X $\to$ Y függőséget. \\ +\textit{Jobboldalak szétvágása}: $X \to A_1A_2...A_n$ akkor és csak akkor teljesül R relációra, ha $X \to A_1$, $X \to A_2$,..., $X \to A_n$ is teljesül R-en. Példa: A$\to$BC ekvivalens A$\to$B és +A$\to$C függőségek kettősével. Baloldalak szétvágására nincs szabály, ezért elég nézni, ha a FF-k jobboldalán egyetlen attribútum szerepel. \\ +Példa funkcionális függőségekre: Sörivók(név, cím, kedveltSörök, gyártó, kedvencSör) táblában név $\to$ cím kedvencSör (egy ua., mint név $\to$ cím és név $\to$ kedvencSör), kedveltSörök $\to$ gyártó. \\ \\ +\textit{Kulcs, szuperkulcs} Funkcionális függőség X $\to$ Y speciális esetben, ha Y = U, ez a kulcsfüggőség. R(U) relációséma esetén az U attribútumhalmaz egy K részhalmaza akkor és csak akkor szuperkulcs, ha a K $\to$ U FF teljesül. A kulcsot tehát a függőség fogalma alapján is lehet definiálni: olyan K attribútumhalmazt nevezünk kulcsnak, amelytől az összes többi attribútum függ, de K-ból bármely attribútumot elhagyva ez már nem teljesül (vagyis minimális szuperkulcs). Példa az előző alapján: $\{$név, kedveltSörök$\}$ szuperkulcs, ez a két attr. meghatározza funkcionálisan a maradék attr-kat. \\ \\ +\textit{Függőségek implikációja}: F implikálja $X \to Y$-t, ha minden olyan táblában, amelyben F összes függősége teljesül, $X \to Y$ is teljesül. Jelölés: $F \models X \to Y$, ha F implikálja $X \to Y$–et. \\ +Legyenek $X_1 \to A_1$, $X_1 \to A_2$,..., $X_1 \to A_n$ adott FF-k, szeretnénk tudni, hogy $Y \to B$ teljesül-e olyan relációkra, amire az előbbi FF-k teljesülnek. Példa: $A \to B$ és $B \to C$ teljesülése esetén $A \to C$ biztosan teljesül. $Y \to B$ teljesülésének ellenőrzésekor vegyünk két sort, amelyek megegyeznek az összes Y-beli attribútumon. Használjuk a megadott FF-ket annak igazolására, hogy az előbbi két sor más attribútumokon is meg kell, hogy egyezzen. Ha B egy ilyen attribútum, akkor $Y \to B$ teljesül. Egyébként az előbbi két sor olyan előfordulást ad majd, ami az összes előírt egyenlőséget teljesíti, viszont $Y \to B$ mégsem teljesül, azaz $Y \to B$ nem következménye a megadott FF-eknek. \\ \\ +Armstrong-axiómák: Legyen R(U) relációséma és $X,Y \subseteq U$, és jelölje XY az X és Y attribútumhalmazok egyesítését. F legyen funkcionális függőségek tetsz. halmaza. \\ +\begin{itemize} + \item FD1 (reflexivitás): $Y \subseteq X$ esetén $X \to Y$. + \item FD2 (bővíthetőség): $X \to Y$ és tetszőleges Z esetén $XZ \to YZ$. + \item FD3 (tranzitivitás): $X \to Y$ és $Y \to Z$ esetén $X \to Z$. +\end{itemize} +Az Armstrong-axiómarendszer helyes és teljes, azaz minden levezethető függőség implikálódik is, illetve azok a függőségek, amelyeket F implikál azok le is vezethetők F-ből. $F \vdash X \to Y \iff F \models X \to Y$\\ \\ +\textit{Levezetés}: $X \to Y$ levezethető F-ből, ha van olyan $X_1 \to Y_1$, ..., $X_k \to Y_k$,..., $X \to Y$ véges levezetés, hogy $\forall k$-ra $X_k \to Y_k \in F$ vagy $X_k \to Y_k$ az FD1, FD2, FD3 axiómák alapján kapható a levezetésben előtte szereplő függőségekből. Jelölés: $F \vdash X \to Y$, ha $X \to Y$ levezethető F-ből. \\ +További levezethető szabályok: +\begin{itemize} + \item Összevonhatósági szabály: $F \vdash X \to Y$ és $F \vdash X \to Z$ esetén $F \vdash X \to YZ$. + \item Pszeudotranzitivitás: $F \vdash X \to Y$ és $F \vdash WY \to Z$ esetén $F \vdash XW \to Z$. + \item Szétvághatósági szabály: $F \vdash X \to Y$ és $Z \subseteq Y$ esetén $F \vdash X \to Z$. +\end{itemize} +\textit{Attribútumhalmaz lezártja}: Adott R séma és F funkcionális függőségek halmaza mellett, $X^+$ az összes olyan A attribútum halmaza, amire X $\to$ A következik F-ből. (R,F) séma esetén legyen $X \subseteq R$. Definíció: $X^{+(F)}:=\{A | F \vdash X \to A\}$ az X attribútumhalmaz lezárása F-re nézve. Lemma: $F \vdash X \to Y \iff Y \subseteq X^+$. Következménye: az implikációs probléma megoldásához elég az $X^+$-t hatékonyan kiszámolni. \\ +Az implikációt lezárással is el lehet dönteni. Kiindulás: $Y^+ = Y$. Indukció: Olyan FF-ket keresünk, melyeknek a baloldala már benne van $Y^+$-ban. Ha $X \to A$ ilyen, A-t hozzáadjuk $Y^+$-hoz. \\\\ +\textit{FF-ek vetítése}: Motiváció: ,,normalizálás", melynek során egy reláció sémát több sémára bonthatunk szét. Példa: ABCD $F=\{AB \to C, C \to D, D \to A\}$. Bontsuk fel ABC és AD-re. Milyen FF-k teljesülnek ABC –n? Nem csak $AB \to C$, de $C \to A$ is! Vetület kiszámítása: Induljunk ki a megadott FF-ekből és keressük meg az összes nem triviális FF-t, ami a megadott FF-ekből következik. (Nem triviális = a jobboldalt nem tartalmazza a bal.) Csak azokkal az FF-kel foglalkozzunk, amelyekben a projektált séma attribútumai szerepelnek. Függőségek vetülete: Adott (R,F), és $R_i \subseteq R $ esetén: $\Pi_{R_i}(F):=\{X \to Y | F \vdash X \to Y, XY \subseteq R_i\}$.\\ \\ +\textit{A többértékű függőség} (TÉF): az R reláció fölött $X \to\to Y$ teljesül: ha bármely két sorra, amelyek megegyeznek az X minden attribútumán, az Y attribútumaihoz tartozó értékek felcserélhetőek, azaz a keletkező két új sor R-beli lesz. Más szavakkal: X minden értéke esetén az Y-hoz tartozó értékek függetlenek az R-X-Y értékeitől. Definíció: $X,Y \subseteq R, Z:=R-XY$ esetén $X \to\to Y$ többértékű függőség. A függőség akkor teljesül egy táblában, ha bizonyos mintájú sorok létezése garantálja más sorok létezését. \\ +Formális definíció: Egy R sémájú r reláció kielégíti az $X \to\to Y$ függőséget, ha $t,s \in r$ és t[X]=s[X] esetén létezik olyan $u,v \in r$, amelyre u[X]=v[X]=t[X]=s[X], u[Y]=t[Y], u[Z]=s[Z], +v[Y]=s[Y], v[Z]=t[Z]. Állítás: Elég az u,v közül csak az egyik létezését megkövetelni. +Példa: Sörivók(név, cím, tel, kedveltSörök) tábla. A sörivók telefonszámai függetlenek az általuk kedvelt söröktől: név$\to\to$tel és név$\to\to$kedveltSörök. Így egy-egy sörivó minden telefonszáma minden általa kedvelt sörrel kombinációban áll. Ez a jelenség független a funkcionális függőségektől. \\ +TÉF szabályok: +\begin{itemize} + \item Minden FF TÉF. Ha $X \to Y$ és két sor megegyezik X-en, Y-on is megegyezik, emiatt ha ezeket felcseréljük, az eredeti sorokat kapjuk vissza, azaz: $X \to\to Y$. + \item Komplementálás : Ha $X \to\to Y$ és Z jelöli az összes többi attribútum halmazát, akkor $X \to\to Z$. + \item Nem lehet darabolni. + \item Állítás: $X \to\to Y$-ből nem következik, hogy $X \to\to A$, ha $A \in Y$. (A jobb oldalak nem szedhetők szét!) + \item Nem tranzitív. +\end{itemize} +A veszteségmentesség, függőségőrzés definíciójában most F funkcionális függőségi halmaz helyett D függőségi halmaz többértékű függőségeket is tartalmazhat. \\ +Tétel: A $d=(R_1,R_2)$ akkor és csak akkor veszteségmentes dekompozíciója R-nek, ha $D \vdash R_1 \cap R_2 \to\to R_1-R_2$. + +\subsection{Normálformák} + +\begin{itemize} + \item \textit{Boyce-Codd normálforma}: R reláció BCNF-ben van, ha minden X $\to$ Y nemtriviális FF-re R-ben X szuperkulcs. Nemtriviális: Y nem része X-nek. Szuperkulcs: tartalmaz kulcsot (ő maga is lehet kulcs). Ha van olyan következmény FF F-ben, ami sérti a BCNF-t, akkor egy F-beli FF is sérti. Kiszámítjuk $X^+$-t: Ha itt nem szerepel az összes attribútum, X nem szuperkulcs. + \item Bizonyos FF halmazok esetén a felbontáskor elveszíthetünk függőségeket. \textit{3. normálformában} (3NF) úgy módosul a BCNF feltétel, hogy az előbbi esetben nem kell dekomponálnunk. Egy attribútum elsődleges attribútum (prím), ha legalább egy kulcsnak eleme. X $\to$ A megsérti 3NF-t akkor és csak akkor, ha X nem szuperkulcs és A nem prím. + \item A \textit{4.normálforma} hasonlít a BCNF-re, azaz minden nem triviális többértékű függőség bal oldala szuperkulcs. A TÉF-ek okozta redundanciát a BCNF nem szünteti meg. A megoldás: a negyedik normálforma. A negyedik normálformában (4NF), amikor dekomponálunk, a TÉF-eket úgy kezeljük, mint az FF-eket, a kulcsok megtalálásánál azonban nem számítanak.\\ + Egy R reláció 4NF -ben van ha: minden $X \to\to Y$ nemtriviális TÉF esetén X szuperkulcs. Nemtriviális TÉF: Y nem részhalmaza X-nek, és X és Y együtt nem adják ki az összes attribútumot. A szuperkulcs definíciója ugyanaz marad, azaz csak az FF-ektől függ. + Definíció: R 4NF-ben van D-re nézve, ha $XY \neq R$, $Y \not\subset X$, és $D \vdash X \to\to Y$ esetén $D \vdash X \to R$.\\ + Definíció: $d=\{R_1,...,R_k\}$ dekompozíció 4NF-ben van D-re nézve, ha minden $R_i$ 4NF-ben van $\Pi_{R_i}(D)$-re nézve.\\ + Állítás: Ha R 4NF-ben van, akkor BCNF-ben is van. Következmény: Nincs mindig függőségőrző és veszteségmentes 4NF dekompozíció.\\ + Veszteségmentes 4NF dekompozíciót mindig tudunk készíteni a naiv BCNF dekomponáló algoritmushoz hasonlóan. \\ + Ha R 4NF-ben van, akkor BCNF-ben is. +\end{itemize} +Tételek: Mindig van VM BCNF-ra és VM FŐ 3NF-ra való felbontás. + +\subsection{Dekompozíciók} + +A rosszul tervezettség anomáliákat is eredményez. A jó tervezésnél cél az anomáliák és a redundancia megszüntetése. +\begin{figure}[H] + \centering + \includegraphics[width=0.6\textwidth]{img/dekomp1.png} + \caption{Sörivó(név, cím, kedveltSörök, gyártó, kedvencSör) tábla} +\end{figure} +\begin{itemize} + \item Módosítási anomália: ha Janeway-t Jane-re módosítjuk, megtesszük-e ezt minden sornál? Egy adat egy előfordulását megváltoztatjuk, más előfordulásait azonban nem. + \item Törlési anomália: Ha senki sem szereti a Bud sört, azzal töröljük azt az infót is, hogy ki gyártotta. Törléskor olyan adatot is elveszítünk, amit nem szeretnénk. + \item Beillesztési anomália: és felvinni ilyen gyártót? Megszorítás, trigger kell, hogy ellenőrizni tudjuk (pl. a kulcsfüggőséget). +\end{itemize} +\textit{Dekomponálás} (felbontás): A fenti problémáktól dekomponálással (felbontással) tudunk megszabadulni! Definíció: $d=\{R_1,...,R_k\}$ az (R,F) dekompozíciója, ha nem marad ki attribútum, azaz $R_1\cup ...\cup R_k=R$.(Az adattábla felbontását projekcióval végezzük). \\ +Elvárások: +\begin{enumerate} + \item Veszteségmentes legyen a felbontás, vagyis ne legyen információvesztés. A fenti jelölésekkel: ha $r = \Pi_{R_1}(r) \bowtie ... \bowtie \Pi_{R_k}(r)$ teljesül, akkor az előbbi összekapcsolásra azt mondjuk, hogy veszteségmentes. Itt r egy R sémájú relációt jelöl. Chase-teszt a veszteségmentességhez: Készítünk egy felbontást. A felbontás eleminek összekapcsolásából veszünk egy sort. Az algoritmussal bebizonyítjuk, hogy ez a sor az eredeti relációnak is sora. + \item A vetületek legyenek jó tulajdonságúak, és a vetületi függőségi rendszere egyszerű legyen (normálformák: BCNF, 3NF def. később) + \item Függőségek megőrzése a vetületekben (FŐ) A dekompozíciókban érvényes függőségekből következzen az eredeti sémára kirótt összes függőség. Adott (R,F) esetén $d=\{R_1,...,R_k\}$ függőségőrző dekompozíció akkor és csak akkor, ha minden F-beli függőség levezethető a vetületi függőségekből: minden $x \to Y \in F$ esetén $\Pi_{R_1}(F) \cup ... \cup \Pi_{R_k}(F) \vdash X \to Y$. +\end{enumerate} +A függőségőrzésből nem következik a veszteségmentesség és a veszteségmentességből nem következik a +függőségőrzés. \\ + +\end{document} diff --git a/18.Adatbázisok tervezése és lekérdezése/img/dekomp1.png b/20. Adatbázisok tervezése és lekérdezése/img/dekomp1.png similarity index 100% rename from 18.Adatbázisok tervezése és lekérdezése/img/dekomp1.png rename to 20. Adatbázisok tervezése és lekérdezése/img/dekomp1.png diff --git a/18.Adatbázisok tervezése és lekérdezése/img/ek.png b/20. Adatbázisok tervezése és lekérdezése/img/ek.png similarity index 100% rename from 18.Adatbázisok tervezése és lekérdezése/img/ek.png rename to 20. Adatbázisok tervezése és lekérdezése/img/ek.png diff --git a/18.Adatbázisok tervezése és lekérdezése/img/ek1.png b/20. Adatbázisok tervezése és lekérdezése/img/ek1.png similarity index 100% rename from 18.Adatbázisok tervezése és lekérdezése/img/ek1.png rename to 20. Adatbázisok tervezése és lekérdezése/img/ek1.png diff --git a/18.Adatbázisok tervezése és lekérdezése/img/ek2.png b/20. Adatbázisok tervezése és lekérdezése/img/ek2.png similarity index 100% rename from 18.Adatbázisok tervezése és lekérdezése/img/ek2.png rename to 20. Adatbázisok tervezése és lekérdezése/img/ek2.png diff --git a/18.Adatbázisok tervezése és lekérdezése/img/ek3.png b/20. Adatbázisok tervezése és lekérdezése/img/ek3.png similarity index 100% rename from 18.Adatbázisok tervezése és lekérdezése/img/ek3.png rename to 20. Adatbázisok tervezése és lekérdezése/img/ek3.png diff --git a/18.Adatbázisok tervezése és lekérdezése/img/ek4.png b/20. Adatbázisok tervezése és lekérdezése/img/ek4.png similarity index 100% rename from 18.Adatbázisok tervezése és lekérdezése/img/ek4.png rename to 20. Adatbázisok tervezése és lekérdezése/img/ek4.png diff --git a/18.Adatbázisok tervezése és lekérdezése/img/ek5.png b/20. Adatbázisok tervezése és lekérdezése/img/ek5.png similarity index 100% rename from 18.Adatbázisok tervezése és lekérdezése/img/ek5.png rename to 20. Adatbázisok tervezése és lekérdezése/img/ek5.png diff --git a/18.Adatbázisok tervezése és lekérdezése/img/ek6.png b/20. Adatbázisok tervezése és lekérdezése/img/ek6.png similarity index 100% rename from 18.Adatbázisok tervezése és lekérdezése/img/ek6.png rename to 20. Adatbázisok tervezése és lekérdezése/img/ek6.png diff --git a/18.Adatbázisok tervezése és lekérdezése/img/ek7.png b/20. Adatbázisok tervezése és lekérdezése/img/ek7.png similarity index 100% rename from 18.Adatbázisok tervezése és lekérdezése/img/ek7.png rename to 20. Adatbázisok tervezése és lekérdezése/img/ek7.png diff --git a/18.Adatbázisok tervezése és lekérdezése/img/ek8.png b/20. Adatbázisok tervezése és lekérdezése/img/ek8.png similarity index 100% rename from 18.Adatbázisok tervezése és lekérdezése/img/ek8.png rename to 20. Adatbázisok tervezése és lekérdezése/img/ek8.png diff --git a/18.Adatbázisok tervezése és lekérdezése/img/ek9.png b/20. Adatbázisok tervezése és lekérdezése/img/ek9.png similarity index 100% rename from 18.Adatbázisok tervezése és lekérdezése/img/ek9.png rename to 20. Adatbázisok tervezése és lekérdezése/img/ek9.png diff --git a/18.Adatbázisok tervezése és lekérdezése/img/null.png b/20. Adatbázisok tervezése és lekérdezése/img/null.png similarity index 100% rename from 18.Adatbázisok tervezése és lekérdezése/img/null.png rename to 20. Adatbázisok tervezése és lekérdezése/img/null.png diff --git a/18.Adatbázisok tervezése és lekérdezése/img/oo.png b/20. Adatbázisok tervezése és lekérdezése/img/oo.png similarity index 100% rename from 18.Adatbázisok tervezése és lekérdezése/img/oo.png rename to 20. Adatbázisok tervezése és lekérdezése/img/oo.png diff --git a/18.Adatbázisok tervezése és lekérdezése/img/plsql1.png b/20. Adatbázisok tervezése és lekérdezése/img/plsql1.png similarity index 100% rename from 18.Adatbázisok tervezése és lekérdezése/img/plsql1.png rename to 20. Adatbázisok tervezése és lekérdezése/img/plsql1.png diff --git a/18.Adatbázisok tervezése és lekérdezése/img/psm1.png b/20. Adatbázisok tervezése és lekérdezése/img/psm1.png similarity index 100% rename from 18.Adatbázisok tervezése és lekérdezése/img/psm1.png rename to 20. Adatbázisok tervezése és lekérdezése/img/psm1.png diff --git a/18.Adatbázisok tervezése és lekérdezése/img/psm2.png b/20. Adatbázisok tervezése és lekérdezése/img/psm2.png similarity index 100% rename from 18.Adatbázisok tervezése és lekérdezése/img/psm2.png rename to 20. Adatbázisok tervezése és lekérdezése/img/psm2.png diff --git a/18.Adatbázisok tervezése és lekérdezése/img/psm3.png b/20. Adatbázisok tervezése és lekérdezése/img/psm3.png similarity index 100% rename from 18.Adatbázisok tervezése és lekérdezése/img/psm3.png rename to 20. Adatbázisok tervezése és lekérdezése/img/psm3.png diff --git a/18.Adatbázisok tervezése és lekérdezése/img/relalg1.png b/20. Adatbázisok tervezése és lekérdezése/img/relalg1.png similarity index 100% rename from 18.Adatbázisok tervezése és lekérdezése/img/relalg1.png rename to 20. Adatbázisok tervezése és lekérdezése/img/relalg1.png diff --git a/18.Adatbázisok tervezése és lekérdezése/img/sql1.png b/20. Adatbázisok tervezése és lekérdezése/img/sql1.png similarity index 100% rename from 18.Adatbázisok tervezése és lekérdezése/img/sql1.png rename to 20. Adatbázisok tervezése és lekérdezése/img/sql1.png diff --git a/18.Adatbázisok tervezése és lekérdezése/img/sql2.png b/20. Adatbázisok tervezése és lekérdezése/img/sql2.png similarity index 100% rename from 18.Adatbázisok tervezése és lekérdezése/img/sql2.png rename to 20. Adatbázisok tervezése és lekérdezése/img/sql2.png diff --git a/21. Adatbázisok optimalizálása és konkurencia kezelése/21. Adatbázisok optimalizálása és konkurencia kezelése.pdf b/21. Adatbázisok optimalizálása és konkurencia kezelése/21. Adatbázisok optimalizálása és konkurencia kezelése.pdf new file mode 100644 index 0000000..a522539 Binary files /dev/null and b/21. Adatbázisok optimalizálása és konkurencia kezelése/21. Adatbázisok optimalizálása és konkurencia kezelése.pdf differ diff --git a/21. Adatbázisok optimalizálása és konkurencia kezelése/21. Adatbázisok optimalizálása és konkurencia kezelése.tex b/21. Adatbázisok optimalizálása és konkurencia kezelése/21. Adatbázisok optimalizálása és konkurencia kezelése.tex new file mode 100644 index 0000000..8d9aa63 --- /dev/null +++ b/21. Adatbázisok optimalizálása és konkurencia kezelése/21. Adatbázisok optimalizálása és konkurencia kezelése.tex @@ -0,0 +1,761 @@ +\documentclass[margin=0px]{article} + +\usepackage{listings} +\usepackage[utf8]{inputenc} +\usepackage{graphicx} +\usepackage{float} +\usepackage[a4paper, margin=0.7in]{geometry} +\usepackage{amsthm} +\usepackage{amssymb} +\usepackage{fancyhdr} +\usepackage{setspace} + +\onehalfspacing + +\makeatletter +\renewcommand\paragraph{% + \@startsection{paragraph}{4}{0mm}% + {-\baselineskip}% + {.5\baselineskip}% + {\normalfont\normalsize\bfseries}} +\makeatother + +\renewcommand{\figurename}{ábra} +\newenvironment{tetel}[1]{\paragraph{#1 \\}}{} + +\pagestyle{fancy} +\lhead{\it{PTI BSc Záróvizsga tételek}} +\rhead{21. Adatbázisok optimalizálása és konkurencia kezelése} + +\title{\textbf{{\Large ELTE IK - Programtervező Informatikus BSc} \vspace{0.2cm} \\ {\huge Záróvizsga tételek}} \vspace{0.3cm} \\ 21. Adatbázisok optimalizálása és konkurencia kezelése} +\author{} +\date{} + +\begin{document} +\maketitle + +\begin{tetel}{Adatbázisok optimalizálása és konkurencia kezelése} + Az adatbáziskezelő rendszerek feladata, részei. Indexstruktúrák, lekérdezések végrehajtása, optimalizálási stratégiák. Tranzakciók feldolgozása, naplózás és helyreállítás, konkurencia-kezelés. +\end{tetel} + +\section{Az adatbázis-kezelő rendszerek feladata, részei} + +Adatbázis-kezelő rendszer alatt olyan számítógépprogramot értünk, mely megvalósítja nagy tömegű adat biztonságos +tárolását, gyors lekérdezhetőségét és módosíthatóságát, tipikusan egyszerre több felhasználó számára. + +Az adatbázis-kezelési tevékenységeket két csoportra szokás osztani: adatmanipulációra (lekérdezés), +illetve definiálásra (adatszerkezetek kialakítása, módosítása). Az adatok manipulációjára szolgáló nyelveket összefoglalóan +Data Manipulation Language-nek (DML), míg a definíciós eszközökkel rendelkező nyelveket Data Definition Language-nek (DDL) +szokás nevezni. + +\begin{figure}[H] + \centering + \includegraphics[width=0.7\linewidth]{img/db_felepites} + \caption{Az adatbázis-kezelő rendszer alkotórészei.} + \label{fig:db_felepites} +\end{figure} + +\subsection{Az egyes alkotórészek rövid jellemzése} +\noindent \textbf{Lekérdezésfordító}: A lekérdezésfordító elemzi és optimalizálja a lekérdezést, ami alapján +elkészíti a lekérdezés-végrehajtási tervet (lekérdezéstervet).\\ + +\noindent \textbf{Végrehajtómotor}: A végrehajtómotor a lekérdezésfordítótól megkapja a lekérdezéstervet, majd kisebb +adatdarabokra (tipikusan rekordokra, egy reláció soraira) vonatkozó kérések sorozatát adja át az erőforrás-kezelőnek.\\ + +\noindent \textbf{Erőforrás-kezelő}: Az erőforrás-kezelő ismeri a relációkat tartalmazó adatfájlokat, a fájlok +rekordjainak formátumát, méretét, valamint az indexfájlokat. Az adatkéréseket az erőforrás-kezelő lefordítja lapokra, +amit átad a pufferkezelőnek.\\ + +\noindent \textbf{Pufferkezelő}: Feladata, hogy a másodlagos adattárolóról (lemez, stb.) az adatok megfelelő részét olvassa +be a központi memória puffereibe. A pufferkezelő információkat cserél a tárkezelővel, hogy megkapja az adatokat +a lemezről.\\ + +\noindent \textbf{Tárkezelő}: Adatokat ír-olvas a másodlagos adattárolóról. Előfordulhat, hogy igénybe veszi az oprendszer +parancsait is, de sokszor közvetlenül a lemezkezelőhöz intézi a parancsait.\\ + +\noindent \textbf{Tranzakciókezelő}: A lekérdezéseket és más tevékenységeket tranzakciókba szervezzük. A tranzakciók olyan +egységek, amelyeket atomosan és elkülöníthetően kell végrehajtani, valamint a végrehajtásnak tartósnak kell lennie, illetve +a tranzakció végrehajtása nem állíthat elő érvénytelen adatbázis-állapotot (azaz konzisztens). Ezeket a követelményeket +az ACID mozaikszóval szokás összefoglalni. A tranzakciókezelő hajtatja végre a tranzakciókat és gondoskodik a naplózásról +és helyreállításról, valamint a konkurenciakezelésről.\\ + +\section{Indexstruktúrák} + +Az indexek keresést gyorsító segédstruktúrák. Több mezőre is lehet indexet készíteni. Nem csak a +főfájlt, hanem az indexet is karban kell tartani, ami plusz költséget jelent. Ha a keresési mező egyik +indexmezővel sem esik egybe akkor kupac szervezést jelent. Az indexrekordok szerkezete (a,p) , ahol +"a" egy érték az indexelt oszlopban, "p" egy blokkmutató, arra a blokkra mutat, amelyben az A=a +értékű rekordot tároljuk. Az index mindig rendezett az indexértékek szerint. + +\subsection{Elsődleges index} + +Elsődleges index esetén a főfájl is rendezett (az indexmező szerint), így emiatt csak egy elsődleges +indexet lehet megadni. Elég a főfájl minden blokkjának legkisebb rekordjához készíteni +indexrekordot, így azok száma: $T(I) = B$ (ritka index). Indexrekordból sokkal több fér egy blokkba, mint +a főfájl rekordjaiból: $bf(I) >> bf$, azaz az indexfájl sokkal kisebb rendezett fájl, mint a főfájl: +$B(I) = \frac{B}{bf(I)} << B = \frac{T}{bf}$. + +Keresésnél, mivel az indexfájlban nem szerepel minden érték, ezért csak fedő értéket kereshetünk, a +legnagyobb olyan indexértéket, amely a keresett értéknél kisebb vagy egyenlő. Fedő érték keresése +az index rendezettsége miatt bináris kereséssel történik: $\log_{2}(B(I))$. A fedő indexrekordban szereplő +blokkmutatónak megfelelő blokkot még be kell olvasni. Így a költség $1+\log_{2}(B(I)) << \log_{2}(B)$(rendezett +eset). +Módosításnál a rendezett fájlba kell beszúrni. Ha az első rekord változik a blokkban, akkor az +indexfájlba is be kell szúrni, ami szintén rendezett. A megoldás az, hogy üres helyeket hagyunk a +főfájl, és az indexfájl blokkjaiban is. Ezzel a tárméret duplázódhat, de a beszúrás legfeljebb egy +főrekord, és egy indexrekord visszaírását jelenti. + +\subsection{Másodlagos index} + +Másodlagos index esetén a főfájl rendezetlen (az indexfájl mindig rendezett). Másodlagos indexből +többet is meg lehet adni. A főfájl minden rekordjához kell készíteni indexrekordot, így az +indexrekordok száma: $T(I) = T$ (sűrű index). Indexrekordból sokkal több fér egy blokkba, mint a főfájl +rekordjaiból: $bf(I) >> bf$, azaz az indexfájl sokkal kisebb fájl, mint a főfájl: $B(I) = \frac{T}{bf(I)} << + B=\frac{T}{bf}$. +Az indexben a keresés az index rendezettsége miatt bináris kereséssel történik: $\log_{2}(B(I))$ . A talált +indexrekordban szereplő blokkmutatónak megfelelő blokkot még be kell olvasni. Így a költség +$1+\log_{2}(B(I)) << \log_{2}(B)$ (rendezett eset). Az elsődleges indexnél rosszabb a keresési idő, mert több az +indexrekord. +A főfájl kupac szervezésű. Rendezett fájlba kell beszúrni. Ha az első rekord változik a blokkban, akkor +az indexfájlba is be kell szúrni, ami szintén rendezett. Megoldás: üres helyeket hagyunk a főfájl, és az +indexfájl blokkjaiban is. Ezzel a tárméret duplázódhat, de a beszúrás legfeljebb egy főrekord és egy +indexrekord visszaírását jelenti. + +\subsection{Bitmap index} + +A bitmap indexeket az oszlopok adott értékeihez szokták hozzárendelni, az alábbi módon: +\begin{itemize} + \item Ha az oszlopban az $i$. sor értéke megegyezik az adott értékkel, akkor a bitmap index $i$. tagja + egy 1-es. + + \item Ha az oszlopban az $i$. sor értéke viszont nem egyezik meg az adott értékkel, akkor a bitmap + index $i$. tagja egy 0. +\end{itemize} + +Így egy lekérdezésnél csak megfelelően össze kell AND-elni, illetve OR-olni a bitmap indexeket, és az +így kapott számsorozatban megkeresni, hol van 1-es. +A bináris értékeket szokás szakaszhossz kódolással tömöríteni a hatékonyabb tárolás érdekében. + +\subsection{Többszintű indexek} + +Az indexfájl (1. indexszint) is fájl, ráadásul rendezett, így ezt is meg lehet indexelni, elsődleges index- +szel. A főfájl lehet rendezett vagy rendezetlen (az indexfájl mindig rendezett) . A $t$. szintű index: az +indexszinteket is indexeljük, összesen $t$ szintig. +A $t$. szinten ($I(t)$) bináris kereséssel keressük meg a fedő indexrekordot. Követjük a mutatót, minden +szinten, és végül a főfájlban: $\log_{2}(B(I(t))) + t$ blokkolvasás. Ha a legfelső szint 1 blokkból áll, akkor $t+1$ +blokkolvasást jelent. Minden szint blokkolási faktora megegyezik, mert egyforma hosszúak az +indexrekordok. + +A $t$. szinten 1 blokk: $1=\frac{B}{bf(I)^{t}}$. Azaz $t=\log_{bf(I)}(B) < \log_{2}(B) $, tehát jobb a rendezett fájlszervezésnél. A +$log_{bf(I)}(B) < \log_{2}(B(I)) $ is teljesül általában, így az egyszintű indexeknél is +gyorsabb. + +\subsection{B-fa index} + +Logikailag az index egy rendezett lista. Fizikailag a rendezett sorrendet táblába rendezett mutatók +biztosítják. A fa struktúrájú indexek B-fákkal ábrázolhatóak. A B-fák megoldják a bináris fák +kiegyenlítetlenségi problémáját, mivel "alulról" töltjük fel őket. A B-fa egy csomópontjához több +kulcsérték tartozhat. A mutatók más csomópontokra mutatnak, és így az összes kulcsértékre az adott +csomóponton. + +Mivel a B-fák kiegyenlítettek (minden ág egyenlő hosszú, vagyis ugyanazon a szinten fejeződik be), +kiküszöbölik a változó elérési időket, amik a bináris fákban megfigyelhetőek. Bár a kulcsértékek és a +hozzájuk kapcsolódó címek még mindig a fa minden szintjén megtalálhatók, és ennek eredménye: +egyenlőtlen elérési utak, és egyenlőtlen elérési idő, valamint komplex fakeresési algoritmus az +adatfájl logikailag soros olvasására. Ez kiküszöbölhető, ha nem engedjük meg az adatfájl címek +tárolását levélszint felett. Ebből következően: minden elérés ugyanolyan hosszú utat vesz igénybe, +aminek egyenlő elérési idő az eredménye, és egy logikailag soros olvasása az adatfájlnak a levélszint +elérésével megoldható. Nincs szükség komplex fakeresési algoritmusra. + +A $B^{+}$-fa egy olyan B-fa, mely legalább 50\%-ban telített. A szerkezeten kívül a telítettséget biztosító +karbantartó algoritmusokat is beleértjük. + +A $B^{*}$-fa egy olyan B-fa, mely legalább 66\%-ban telített. + +\subsection{Hasító index} + +A rekordok edényekbe (bucket) particionálva helyezkednek el, melyekre a $h$ hasítómezőn értelmezett +függvény osztja szét őket. Hatékony egyenlőségi keresés, beszúrás, és törlés jellemzi, viszont nem támogatja +az intervallumos keresést. + +A rekordokat blokkláncokba soroljuk, és a blokklánc utolsó blokkjának +első üres helyére tesszük a rekordokat a beérkezés sorrendjében. A blokkláncok száma lehet előre adott +(statikus hasítás, ekkor a számot K-val jelöljük), vagy a tárolt adatok alapján változhat (dinamikus hasítás). +A besorolás az indexmező értékei alapján történik. Egy $h(x) \in \left\{1,..,K\right\}$ hasító függvény értéke mondja meg, +hogy melyik kosárba tartozik a rekord, ha $x$ volt az indexmező értéke a rekordban. A hasító függvény +általában maradékos osztáson alapul (például $mod(K)$). Akkor jó egy hasító függvény, ha nagyjából egyforma +hosszú blokkláncok keletkeznek, azaz egyenletesen sorolja be a rekordokat. Ekkor a blokklánc $\frac{B}{K}$ blokkból áll.\\ + +\noindent A keresés költsége: +\begin{itemize} + \item Ha az indexmező és keresési mező eltér, akkor kupac szervezést jelent. + \item Ha az indexmező és keresési mező megegyezik, akkor csak elég a $h(a)$ sorszámú kosarat végignézni, + amely $\frac{B}{K}$blokkból álló kupacnak felel meg, azaz $\frac{B}{K}$ legrosszabb esetben. + A keresés így $K$-szorosára gyorsul. +\end{itemize} + +A tárméret $B$, ha minden blokk nagyjából tele van. Nagy $K$ esetén azonban sok olyan blokklánc lehet, +amely egy blokkból fog állni, és a blokkban is csak 1 rekord lesz. Ekkor a keresési idő: 1 blokkbeolvasás, +de $B$ helyett $T$ számú blokkban tároljuk az adatokat. Módosításnál $\frac{B}{K}$ blokkból álló kupac +szervezésű kosarat kell módosítani. + +\section{Lekérdezések végrehajtása, optimalizálása} + +A lekérdezésfeldolgozó egy relációs adatbázis-kezelő komponenseinek azon csoportja, amelyik a felhasználó lekérdezéseit, +valamint adatmódosító utasításait lefordítja adatbázis-műveletekre, amiket végre is hajt. + +\begin{figure}[H] + \centering + \includegraphics[width=0.3\linewidth]{img/queryprocessing} + \caption{A lekérdezésfeldolgozás lépései.} + \label{fig:queryprocessing} +\end{figure} + +A lekérdezés végrehajtása tulajdonképpen az adatbázist manipuláló algoritmusok összessége, azonban a végrehajtás +előtt szükség van a lekérdezések fordítására. \\ + +\noindent A lekérdezés-fordítás lépései: +\begin{enumerate} + \item Elemzés: egy elemző fát építünk fel, amely a lekérdezést és annak szerkezetét jellemzi + + \item Lekérdezésátírás: Az elemző fából egy kezdeti lekérdezéstervet készítünk, amelyet átalakítunk + egy ezzel ekvivalens tervvé, aminek végrehajtási ideje várhatóan kisebb lesz. Elkészül a logikai + lekérdezésterv, amely relációs algebrai kifejezéseket tartalmaz. + + \item A logikai tervet átalakítjuk fizikai tervvé úgy, hogy a logikai terv operátoraihoz kiválasztunk egy + algoritmust, valamint meghatározzuk az operátorok végrehajtási sorrendjét. A fizikai terv olyan részleteket is + tartalmaz, hogy pl. kell-e rendezni, hogyan férünk hozzá az adatokhoz. +\end{enumerate} + +\begin{figure}[H] + \centering + \includegraphics[width=0.5\linewidth]{img/querycompiling} + \caption{A lekérdezésfordítás lépései.} + \label{fig:querycompiling} +\end{figure} + +\subsection{Algebrai optimalizálás} + +A relációs algebrai kifejezéseket minél gyorsabban akarjuk kiszámolni. A kiszámítás költsége arányos a relációs algebrai kifejezés részkifejezéseinek megfelelő relációk tárolási méreteinek összegével. A módszer az, hogy műveleti tulajdonságokon alapuló ekvivalens átalakításokat alkalmazunk, azért, hogy várhatóan kisebb méretű relációk keletkezzenek. Az eljárás heurisztikus, tehát nem az argumentum relációk valódi méretével számol. Az eredmény nem egyértelmű, ugyanis az átalakítások sorrendje nem determinisztikus, így más sorrendben végrehajtva az átalakításokat más végeredményt kaphatunk, de mindegyik általában jobb költségű, mint amiből kiindultunk.\\ + +\noindent Az optimalizáló algoritmus a következő heurisztikus elveken alapul: +\begin{itemize} + \item Minél hamarabb szelektáljunk, hogy a részkifejezések várhatóan kisebb relációk legyenek. + \item A szorzás utáni kiválasztásokból próbáljunk természetes összekapcsolásokat képezni, mert az összekapcsolás hatékonyabban kiszámolható, mint a szorzatból történő kiválasztás. + \item Vonjuk össze az egymás utáni unáris műveleteket (kiválasztásokat és vetítéseket), és ezekből lehetőleg egy kiválasztást, vagy vetítést, vagy kiválasztás utáni vetítést képezzünk. Így csökken a műveletek száma, és általában a kiválasztás kisebb relációt eredményez, mint a vetítés. + \item Keressünk közös részkifejezéseket, amiket így elég csak egyszer kiszámolni a kifejezés kiértékelése során. +\end{itemize} + +\subsection{Relációs algebrai műveletek megvalósítása} + +\subsubsection{Kiválasztás} + +A kiválasztás ($\sigma$) lehetséges megvalósításai: +\begin{itemize} + \item Lineáris keresés: Olvassunk be minden lapot és keressük az egyezéseket (egyenlőségvizsgálat esetén). + Az átlagos költség a lapok száma, ha a mező nem kulcs, illetve a lapok számának fele, ha a mező kulcs. + \item Bináris (logaritmikus) keresés: Csak rendezett mező esetén használható. + \item Elsődleges index használata. + \item Másodlagos index használata. +\end{itemize} + +\noindent \textbf{Összetett kiválasztás}: Előfordulhat, hogy több feltétel van, amelyek és/vagy kapcsolatban vannak egymással. +Megvalósítása: +\begin{itemize} + \item Konjunkciós kiválasztás esetén ($\sigma_{\theta_{1} \wedge ... \wedge \theta_{n}}$): + \begin{itemize} + \item Válasszuk ki a legkisebb költségű $\sigma_{\theta_{i}}$-t, és azt végezzük el (lásd fent), + majd az eredményt szűrjük a többi feltételre. A költség az egyszerű kiválasztás költsége lesz a kiválasztott $\sigma_{\theta_{i}}$-re. + + \item Ha mindegyik $\theta_{i}$ mezőjére van indexünk, akkor keressük az indexekben és adjuk vissza a megfelelő + sorok rowid-jeit. Végül vegyük ezek metszetét. A költség az indexekben való keresés összköltsége + a rekordok beolvasása. + \end{itemize} + + \item Diszjunkciós kiválasztás esetén ($\sigma_{\theta_{1} \vee ... \vee \theta_{n}}$): + \begin{itemize} + \item Lineáris keresés. + + \item Ha mindegyik $\theta_{i}$ mezőjére van indexünk, akkor keressük az indexekben és adjuk vissza a megfelelő + sorok rowid-jeit. Végül vegyük ezek unióját. A költség az indexekben való keresés összköltsége + a rekordok beolvasása. + \end{itemize} +\end{itemize} + +\subsubsection{Vetítés és halmazműveletek} + +Vetítésnél és halmazműveleteknél a duplikátumokat ki kell szűrni.\\ + +\noindent \textbf{Vetítés ($\pi$) megvalósítása}: + +\begin{enumerate} + \item Kezdeti átnézés: eldobjuk a felesleges mezőket. + \item Duplikátumok törlése: ehhez az eredményt rendezzük az összes mező szerint, így a duplikáltak szomszédosak + lesznek. Ezeket kell eldobni. +\end{enumerate} + +\noindent A költség a kezdeti átnézés, a rendezés és a duplikátumok törlésének összköltsége lesz. + +\subsubsection{Összekapcsolások} + +Az összekapcsolásokat (join) többféle módon is el lehet végezni: + +\begin{itemize} + \item \textbf{Beágyazott ciklusú összekapcsolás (nested loop join)}: Bármekkora méretű relációra használható, nem szükséges, hogy + az egyik reláció elférjen a memóriában. Két fajtája van, a sor és a blokk alapú. + \begin{itemize} + \item \textbf{Sor alapú beágyazott ciklusú összekapcsolás}: Legyen R és S a két összekapcsolandó reláció, ezek közül jelölje + S a kisebb méretűt, ez lesz a belső reláció, R pedig a külső. Az algoritmus a következő: menjünk végig R (a külső reláció) + összes során és R minden egyes soránál menjünk végig a belső reláció, S összes során. Ha az aktuálisan vizsgált 2 sor összekapcsolható, akkor írjuk bele az eredménybe. Jó esetben S belefér a memóriába, ekkor csak egyszer kell beolvasni S-t, + majd mindvégig a memóriában tarthatjuk. Ebben az esetben mindkét reláció lapjait egyszer kell beolvasni. Legrosszabb + esetben mindkét relációból csak egy-egy lap fér bele a memóriába. Ekkor R minden egyes soránál végig kell olvasni S-t. + + \item \textbf{Blokk alapú beágyazott ciklusú összekapcsolás}: Az előbbihez képest annyi a különbség, hogy nem soronként + megyünk végig a relációkon. Legyen M a memóriába férő lapok száma. Ekkor minden egyes iterációban R-nek M-1 lapját olvassuk + be, majd szervezzük ezeket valamilyen keresési struktúrába, ahol a kulcs az R és S közös attribútumai. Ezután menjünk + végig laponként S-en, és S memóriában lévő soraiból keressük meg azokat, amelyek összekapcsolhatóak valamely R-ből + beolvasott sorral, majd írjuk bele ezeket az eredményrelációba. + \end{itemize} + + \item \textbf{Összefésüléses rendező összekapcsolás (merge join)}: A relációk az összekapcsolási mezők szerint rendezettek. + Egyesítjük a rendezett relációkat: mutatók az első rekordra mindkét relációban. Beolvasunk S-ből egy rekordcsoportot, ahol az összekapcsolási attribútum értéke megegyezik. Beolvasunk rekordokat R-ből és feldolgozzuk. A rendezett relációkat + csak egyszer kell végigolvasni, ezért az összekapcsolás költsége: rendezés költsége + a 2 reláció lapjainak száma. + + \item \textbf{Hasításos összekapcsolás (hash join)}: Az összekapcsolási attribútumot használjunk hasítókulcsként, ez alapján + particionáljuk R és S sorait hasítással. Ha mindegyik táblából $n$ kosarat szeretnénk, akkor az eredmény: $R_{0},R_{1},..R_{n-1}, S_{0},S_{1},..,S_{n-1}$ kosarak. Ezután az egymáshoz rendelt kosárpárokat összekapcsoljuk blokk alapú beágyazott ciklusú + összekapcsolással, hasítófüggvény alapú indexet használva. +\end{itemize} + +\noindent \textbf{Több tábla összekapcsolása}: Az összekapcsolások kommutatívak és asszociatívak, ezért az eredmény szempontjából +mindegy, hogy milyen sorrendben kapcsoljuk őket össze. A sorrend viszont befolyásolhatja a hatékonyságot, ugyanis rossz választás +esetén a köztes eredmények nagy méretűek lesznek.\\ + +\noindent A legjobb összekapcsolási fa megtalálása $n$ reláció egy halmazához: +\begin{itemize} + \item Hogy megtaláljuk a legjobb összekapcsolási fát n reláció egy $S$ halmazához, + vegyük az összes lehetséges tervet mely így néz ki: $S_{1} \Join (S - S_{1})$, ahol $S_{1}$ az $S$ tetszőleges nem üres részhalmaza. + + \item Rekurzívan számítsuk ki $S$ részhalmazainak összekapcsolásának költségeit, hogy meghatározzuk minden egyes terv költségét. Válasszuk a legolcsóbbat. + + \item Mikor bármely részhalmaz terve kiszámításra került, az újbóli kiszámítás helyett tároljuk el és hasznosítsuk újra amikor ismét szükség lesz rá. +\end{itemize} + +\section{Tranzakciókezelés} + +\noindent \textbf{Konzisztens adatbázis}: Az adatbázisokra különböző megszorítások adhatóak meg. Az adatbázis konzisztens állapotban +van, ha kielégíti az összes ilyen megszorítást. Konzisztens adatbázis egy olyan adatbázis, amely konzisztens állapotban van.\\ + +\noindent A konzisztencia sérülhet a következő esetekben: +\begin{itemize} + \item Tranzakcióhiba: hibásan megírt, rosszul ütemezett, félbehagyott tranzakciók. + \item Adatbázis--kezelési hiba: az adatbázis-kezelő valamelyik komponense nem, vagy rosszul hajtja végre a feladatát. + \item Hardverhiba: elvész egy adat, vagy megváltozik az értéke. + \item Adatmegosztásból származó hiba. +\end{itemize} + +\noindent \textbf{Tranzakció}: Konzisztenciát tartó adatbázis-műveletek sorozata. Ezek után mindig feltesszük, hogy ha +a T tranzakció indulásakor az adatbázis konzisztens állapotban van, akkor ha T egyedül fut le, az adatbázis konzisztens állapotban +lesz a futás végén (közben kialakulhat inkonzisztens állapot). + +\noindent Helyesség feltétele: +\begin{itemize} + \item Ha leáll egy vagy több tranzakció (abort, vagy hiba miatt), akkor is konzisztens adatbázist kapunk. + \item Minden egyes tranzakció induláskor konzisztens adatbázist lát. +\end{itemize} + +\noindent A tranzakcióktól a következő tulajdonságokat szoktuk elvárni (ACID): + +\begin{itemize} + \item Atomosság (A, azaz Atomicity): a tranzakció "mindent vagy semmit" jellegű végrehajtása (vagy teljesen végrehajtjuk, vagy egyáltalán nem hajtjuk végre). + + \item Konzisztencia (C, azaz Consistency): az a feltétel, hogy a tranzakció megőrizze az adatbázis konzisztenciáját, azaz a tranzakció végrehajtása után is teljesüljenek az adatbázisban előírt konzisztenciamegszorítások. + + \item Elkülönítés (I, azaz Isolation): az a tény, hogy minden tranzakciónak látszólag úgy kell lefutnia, mintha ez alatt az idő alatt semmilyen másik tranzakciót sem hajtanánk végre. + + \item Tartósság (D, azaz Durability): az a feltétel, hogy ha egyszer egy tranzakció befejeződött, akkor már soha többé nem veszhet el a tranzakciónak az adatbázison kifejtett hatása. +\end{itemize} +A konzisztenciát mindig adottnak tekintjük. A másik három tulajdonságot viszont az adatbázis-kezelő rendszernek kell biztosítania, de ettől időnként eltekintünk. Feltesszük, hogy az adatbázis adategységekből, elemekből áll. Az adatbáziselem a fizikai adatbázisban tárolt adatok egyfajta funkcionális egysége, amelynek értékét tranzakciókkal lehet elérni (kiolvasni) vagy módosítani (kiírni). Adatbáziselem +pl. a reláció, relációsor, lap.\\ + +\subsection{A tranzakciók alaptevékenységei} + +\noindent A tranzakció és az adatbázis kölcsönhatásának 3 fontos helyszíne van: +\begin{itemize} + \item Az adatbázis elemeit tartalmazó lemezblokkok területe. + \item A pufferkezelő által használt virtuális vagy valós memóriaterület. + \item A tranzakció memóriaterülete. +\end{itemize} + +Ahhoz, hogy a tranzakció egy adatbáziselemet beolvashasson, azt előbb memóriapuffer(ek)be kell hozni, ha még nincs ott. +Ezt követően tudja a puffer(ek) tartalmát a tranzakció saját memóriaterületére beolvasni. Az adatbáziselem új +értékének kiírás fordítva történik: előbb a tranzakció kialakítja az új értéket saját memóriaterületén, majd ez +az érték másolódik át a megfelelő puffer(ek)be. + +A pufferek tartalmának lemezre írásáról a pufferkezelő dönt. Vagy azonnal lemezre írja a változásokat, vagy nem. + +A naplózási algoritmusokn és más tranzakciókezelő algoritmusok tanulmányozása során különböző jelölésekre lesz szükség, +melyekkel a különböző területek közötti adatmozgásokat írhatjuk le. A következő alapműveletek használjuk: + +\begin{itemize} + \item INPUT(X): Az X adatbáziselemet tartalmazó lemezblokk másolása a pufferbe. + \item READ(X,t): Az X adatbáziselem bemásolása a tranzakció $t$ lokális változójába. Ha az X-et tartalmazó blokk még + nincs a memóriában, akkor INPUT(X)-et is beleértjük. + \item WRITE(X,t): A $t$ lokális változó tartalmaz az X adatbáziselem memóriapufferbeli tartalmába másolódik. Ha az X-et + tartalmazó blokk még nincs a pufferben, akkor előbb INPUT(X) is végrehajtódik. + \item OUTPUT(X): Az X adatbáziselemet tartalmazó blokk kiírása lemezre. +\end{itemize} + +\noindent A továbbiakban feltételezzük, hogy egy adatbáziselem nem nagyobb egy blokknál. + +\subsection{Naplózás és helyreállítás} + +Az adatokat meg kell védeni a rendszerhibáktól, ezért szükség van az adatok helyreállíthatóságára. Erre az elsődleges +technika a naplózás, amely valamilyen biztonságos módszerrel rögzíti az adatbázisban végrehajtott módosítások történetét. + +A napló (log) nem más, mint naplóbejegyzések (log records) sorozata, melyek arról tartalmaznak információt, hogy mit tett +egy tranzakció. Rendszerhiba esetén a napló segítségével rekonstruálható, hogy mit tett a tranzakció a hiba fellépéséig. + +\subsubsection{Naplóbejegyzések} + +Úgy kell tekintenünk, hogy a napló, mint fájl kizárólag bővítésre van megnyitva. Tranzakció végrehajtásakor a naplókezelőé +a feladat, hogy minden fontos eseményt rögzítsen a naplóban.\\ + +\noindent Az összes naplózási módszer által használt naplóbejegyzések: +\begin{itemize} + \item $\langle START \ T \rangle$: Ez a bejegyzés jelzi a T tranzakció végrehajtásának kezdetét. + \item $\langle COMMIT \ T \rangle$: A T tranzakció rendben befejeződött, már nem akar további módosításokat végrehajtani. + \item $\langle ABORT \ T \rangle$: A T tranzakció abortált, nem tudott sikeresen befejeződni. Az általa tett változtatásokat + nem kell a lemezre másolni, vagy ha a lemezre másolódtak, akkor vissza kell állítani. +\end{itemize} + +\subsubsection{Semmisségi (undo) naplózás} + +A semmisségi naplózás lényege, hogy ha nem biztos, hogy egy tranzakció műveletei rendben befejeződtek és minden változtatás +lemezre íródott, akkor a tranzakció hatását vissza kell vonni, azaz az adatbázist olyan állapotba kell visszaállítani, +mintha a tranzakció el se kezdődött volna. + +A semmisségi naplózásnál szükség van még egy fajta naplóbejegyzésre, a módosítási bejegyzésre, amely egy $\langle T,X,v\rangle$ +hármas, és azt jelenti, hogy a T tranzakció az X adatbáziselemet módosította, és a módosítás előtti értéke X-nek v volt.\\ + +\noindent \textbf{A semmisségi naplózás szabályai}: +\begin{itemize} + \item Ha a T tranzakció módosítja az X adatbáziselemet, akkor a $\langle T,X,v\rangle$ naplóbejegyzést az előtt kell + a lemezre írni, hogy az új értéket a lemezre írná a rendszer. + + \item Ha a tranzakció hibamentesen befejeződött, akkor a COMMIT bejegyzést csak azután szabad lemezre írni, hogy + a tranzakció által végrehajtott összes módosítás lemezre íródott. +\end{itemize} + +\paragraph{Helyreállítás a semmisségi naplózás használatával} +Tegyük fel, hogy rendszerhiba történt. Ekkor előfordulhat, hogy egy tranzakció nem atomosan hajtódott végre, azaz +bizonyos módosításai már lemezre íródtak, de mások még nem. Ekkor az adatbázis inkonzisztens állapotba kerülhet. +Ezért rendszerhiba esetén gondoskodni kell az adatbázis konzisztenciájának visszaállításáról. Semmisségi naplózás +esetén ez a be nem fejeződött tranzakciók által végrehajtott módosítások semmissé tételét jelenti.\\ + +\noindent \textbf{Visszaállítás ellenőrzőpont nélkül}: A legegyszerűbb módszer. Ekkor a teljes naplót látjuk. Az első feladat +a tranzakciók felosztása sikeresen befejezett és befejezetlen tranzakciókra. Egy T tranzakció sikeresen befejeződött, ha +van a naplóban $\langle COMMIT \ T \rangle$ bejegyzés. Ekkor T önmagában nem hagyhatta inkonzisztens állapotban az adatbázist. +Amennyiben találunk a naplóban $\langle START \ T \rangle$ bejegyzést, de $\langle COMMIT \ T \rangle$ bejegyzést nem, akkor +feltételezhetjük, hogy T végrehajtott olyan módosítást az adatbázisban, amely még nem íródott ki lemezre. Ekkor T nem komplett +tranzakció, hatását semmissé kell tenni. + +\noindent Az algoritmus a következő: +A helyreállítás-kezelő elkezdi vizsgálni a naplóbejegyzéseket az utolsótól kezdve, visszafelé haladva, közben feljegyzi azokat a +T tranzakciókat, melyre $\langle COMMIT \ T \rangle$ vagy $\langle ABORT \ T \rangle$ bejegyzést talált. Visszafelé +haladva, amikor $\langle T,X,v\rangle$ naplóbejegyzést lát: + +\begin{enumerate} + \item Ha T-re találkozott már COMMIT bejegyzéssel, akkor nem tesz semmit. + \item Más esetben T nem teljes vagy abortált. Ekkor a helyreállítás-kezelő az X adatbáziselem értékét v-re változtatja. +\end{enumerate} + +A fenti változtatások végrehajtás után minden nem teljes T tranzakcióra $\langle ABORT \ T \rangle$-t ír a napló végére és +kiváltja a napló lemezre írását. Ezt követően az adatbázis normál használata folytatódhat. + +\subsubsection{Ellenőrzőpont-képzés} + +A helyreállítás elvben a teljes napló átvizsgálását igényelné. Ha undo naplózást használunk, akkor ha egy T tranzakcióra +van COMMIT bejegyzés a naplóban, akkor a T tranzakcióra vonatkozó bejegyzések nem szükségesek a helyreállításhoz, viszont +nem feltétlenül igaz az, hogy törölhetjük a T tranzakcióra vonatkozó COMMIT előtti bejegyzéseket. A legegyszerűbb megoldás +időnként ellenőrzőpontokat készíteni.\\ + +\paragraph{Az egyszerű ellenőrzőpont képzése} +\begin{enumerate} + \item Új tranzakció indítására vonatkozó kérések leállítása. + \item A még aktív tranzakciók befejeződésének és a COMMIT/ABORT bejegyzés naplóba írásának kivárása. + \item A napló lemezre írása. + \item A $\langle CKPT \rangle$ naplóbejegyzés képzése, naplóba írása, majd a napló lemezre írása. + \item Tranzakcióindítási kérések kiszolgálásának újraindítása. +\end{enumerate} + +Az ellenőrzőpont előtt végrehajtott tranzakciók befejeződtek, módosításaik lemezre kerültek. Ezért elég az utolsó ellenőrzőpont utáni +részét elemezni a naplónak helyreállításnál.\\ + +\paragraph{Ellőrzőpont létrehozása a rendszer működése közben} +Az egyszerű ellenőrzőpont-képzéssel az a probléma, hogy nem engedi új tranzakciók elindítását, amíg az aktív tranzakciók be nem +fejeződnek. Ez viszont még sok időt igénybe vehet, a felhasználó számára pedig leállítottnak tűnik a rendszer, hiszen nem +tud új tranzakciót indítani. Ezt nem engedhetjük meg. Egy bonyolultabb módszer azonban lehetővé teszi ellenőrzőpont képzését +anélkül, hogy az új tranzakciók indítását fel kellene függeszteni.\\ + +\noindent E módszer lépései: +\begin{enumerate} + \item $\langle START \ CKPT(T_{1},T_{2},...T_{k}) \rangle$ bejegyzés készítése és a napló lemezre írása. $T_{1},..T_{k}$ + az éppen aktív, befejezetlen tranzakciók. + + \item Meg kell várni a $T_{1},..T_{k}$ tranzakciók befejeződését. Eközben indíthatóak új tranzakciók. + + \item Ha az ellenőrzőpont-képzés kezdetén még aktív $T_{1},..T_{k}$ tranzakciók mindegyike befejeződött, akkor + $\langle END \ CKPT \rangle$ naplóbejegyzés készítése és lemezre írása. +\end{enumerate} + +\noindent Helyreállítás: Visszafelé elemezve megtaláljuk a be nem fejezett tranzakciókat, az ezen tranzakciók által +módosított adatbáziselemek tartalmát a régi értékre állítjuk vissza. Két eset fordulhat elő, vagy $\langle END \ CKPT \rangle$, vagy +$\langle START \ CKPT(T_{1},T_{2},...T_{k}) \rangle$ naplóbejegyzéssel találkozunk előbb. + +\begin{itemize} + \item Ha előbb $\langle END \ CKPT \rangle$ bejegyzéssel találkozunk, akkor az összes be nem fejezett tranzakcióra + vonatkozó bejegyzés megtalálható a legközelebbi $\langle START \ CKPT(T_{1},T_{2},...T_{k}) \rangle$ bejegyzésig. Az ennél + korábbiakkal nem kell foglalkoznunk. + + \item Ha $\langle START \ CKPT(T_{1},T_{2},...T_{k}) \rangle$ bejegyzéssel találkozunk előbb, akkor a hiba + ellenőrzőpont-képzés közben történt. Ekkor a $T_{1},..T_{k}$ tranzakciók közül a legkorábban elindítottnak + a START bejegyzéséig kell visszamenni, ami viszont biztosan az ezt megelőző START CKPT bejegyzés után található. +\end{itemize} + +Általános szabályként, ha END CKPT-ot írunk a lemezre, akkor az azt megelőző START CKPT bejegyzést megelőző +bejegyzésekre nincs szükség a helyreállítás szempontjából. + +\subsubsection{Helyrehozó (redo) naplózás} + +\noindent \textbf{Redo vs. undo naplózás}: +\begin{itemize} + \item A helyrehozó naplózás a semmisségi naplózással szemben helyreállításnál figyelmen kívül hagyja a befejezetlen + tranzakciókat és befejezi a normálisan befejezettek által végrehajtott változtatásokat. + + \item Undo naplózás esetén a COMMIT naplóba írása előtt megköveteljük a módosítások lemezre írását. Ezzel szemben + redo naplózás esetén csak akkor írjuk lemezre a tranzakció által végrehajtott módosításokat, ha a COMMIT bejegyzés + a naplóba íródott és lemezre került. + + \item Undo naplózásnál a módosított elemek régi értékére van szükség helyreállításnál, redo-nál pedig az újra. +\end{itemize} + +\noindent \textbf{Helyrehozó naplózás szabályai}: +Itt a $\langle T,X,v\rangle$ bejegyzés jelentse azt, hogy a T tranzakció az X adatbáziselemet értékét v-re változtatta. +Annak sorrendjét, hogy az adat- és naplóbejegyzések hogyan kell, hogy lemezre kerüljenek, az alábbi, ún. "írj korábban" +naplózási szabály határozza meg: Mielőtt az adatbázis bármely X elemét a lemezen módosítanánk, szükséges, hogy +a $\langle T,X,v\rangle$ és $\langle COMMIT \ T\rangle$ naplóbejegyzések lemezre kerüljenek.\\ + +\noindent \textbf{Helyreállítás helyrehozó naplózás használatával}: + +Ha egy T tranzakció esetén nincs $\langle COMMIT \ T\rangle$ bejegyzés a naplóban, akkor tudjuk, hogy T módosításai +nem kerültek lemezre, így ezekkel nem kell foglalkozni. Ha viszont T befejeződött, azaz van $\langle COMMIT \ T\rangle$ +bejegyzés, akkor vagy lemezre kerültek a módosításai, vagy nem. Ezért meg kell ismételni T módosításait. Szerencsére +a naplóbejegyzések az új értékeket tartalmazzák.\\ + +\noindent Katasztrófa esetén a helyreállítás lépései: +\begin{enumerate} + \item Meghatározni azon tranzakciókat, amelyre van COMMIT bejegyzés a naplóban. + \item Elemezni a naplót az elejéről kezdve. Ha $\langle T,X,v\rangle$ bejegyzést találunk, akkor + ha T befejezett tranzakció, akkor v értékét kell X-be írni. Ha T befejezetlen, nem teszünk semmit. + \item Ha végigértünk a naplón, akkor minden be nem fejezett T tranzakcióra $\langle ABORT \ T\rangle$ + naplóbejegyzést írunk a naplóba és a naplót lemezre írjuk. +\end{enumerate} + +\paragraph{Helyrehozó naplózás ellenőrzőpont-képzéssel} +Helyrehozó naplózásnál a működés közbeni ellenőrzőpont-képzés a következő lépésekből áll: +\begin{enumerate} + \item $\langle START \ CKPT(T_{1},T_{2},...T_{k}) \rangle$ naplóbejegyzés készítése és lemezre írása, ahol + $T_{1}, ... T_{k}$ az aktív tranzakciók. + + \item Az összes olyan adatbáziselem kiírása lemezre, amelyeket olyan tranzakciók írtak pufferbe, amelyek + $\langle START \ CKPT(T_{1},T_{2},...T_{k}) \rangle$ előtt befejeződtek (COMMIT), de puffereik még nem kerültek + lemezre. + + \item $\langle END \ CKPT \rangle$ naplóbejegyzés készítése és lemezre írása. +\end{enumerate} + +\noindent \textbf{Visszaállítás ellenőrzőponttal kiegészített redo naplózásnál}: +Két eset fordulhat elő: az utolsó ellenőrzőponttal kapcsolatos naplóbejegyzés vagy START CKPT, vagy END CKPT. + +\begin{itemize} + \item Tegyük fel, hogy az utolsó ellenőrzőpont-bejegyzés a naplóban END CKPT. Ekkor a\\ + $\langle START \ CKPT(T_{1},T_{2},...T_{k}) \rangle$ előtt befejeződött tranzakciók módosításai már biztosan lemezre kerültek, ezekkel nem kell foglalkoznunk, viszont + a $T_{i}$-kel és a START CKPT bejegyzés után indított tranzakciókkal foglalkoznunk kell. Ekkor olyan visszaállítás kell tennünk, + mint a sima helyrehozó naplózásnál, annyi különbséggel, hogy csak a $T_{i}$-ket és a START CKPT után indított tranzakciókat + kell figyelembe venni. A keresésnél a legkorábbi $\langle START \ T_{i}\rangle$ bejegyzésig kell visszamenni, ahol $T_{i}$ a + $T_{1},...T_{k}$ valamelyike. + + \item Tegyük fel, hogy az utolsó ellenőrzőpont-bejegyzés a naplóban $\langle START \ CKPT(T_{1},T_{2},...T_{k}) \rangle$. + Nem lehetünk biztosak benne, hogy az ez előtt befejeződött tranzakciók módosításai lemezre íródtak, ezért az ezt megelőző + END CKPT előtti $\langle START \ CKPT(S_{1},S_{2},...T_{m}) \rangle$ kell visszamenni. Vissza kell állítani azoknak a + tranzakcióknak a módosításait, amik $S_{i}$-k közül valóak, vagy $\langle START \ CKPT(S_{1},S_{2},...T_{m}) \rangle$ + után indultak és befejeződtek. +\end{itemize} + +\subsubsection{Semmisségi/helyrehozó (undo/redo) naplózás} + +Undo/redo naplózásnál a módosítást jelző naplóbejegyzések $\langle T,X,v,w \rangle$ alakúak, ami azt jelenti, hogy a T tranzakció +az X adatbáziselem értékét v-ről w-re változtatta.\\ + +Undo/redo naplózás esetén a következő előírást kell betartani: Mielőtt az adatbázis bármely X elemének értékét módosítanánk a lemezen, +a $\langle T,X,v,w \rangle$ naplóbejegyzésnek a lemezre kell kerülnie.\\ + +\noindent Speciálisan a $\langle COMMIT \ T\rangle$ bejegyzés megelőzheti és követheti is a módosítások lemezre írását. + +\paragraph{Helyreállítás undo/redo naplózásnál} +\noindent Az alapelvek: +\begin{enumerate} + \item A legkorábbitól kezdve állítsuk helyre minden befejezett tranzakció hatását. + \item A legutolsótól kezdve tegyük semmissé a be nem fejezett tranzakciók hatását. +\end{enumerate} + + +\noindent \textbf{Undo/redo naplózás ellenőrzőpont-képzéssel}: +\begin{enumerate} + \item Írjunk a naplóba $\langle START \ CKPT(T_{1},T_{2},...T_{k}) \rangle$ bejegyzést, ahol $T_{1},..T_{k}$ az aktív + tranzakciók, majd írjuk lemezre a naplót. + + \item Írjuk lemezre azokat a puffereket, amelyek módosított adatbáziselemeket tartalmaznak (piszkos pufferek). Redo naplózással + ellentétben itt minden piszkos puffert lemezre írunk, nem csak a befejezettekét. + + \item Írjunk $\langle END \ CKPT \rangle$ naplóbejegyzést a naplóba és írjuk ki lemezre. +\end{enumerate} + +\subsection{Konkurenciakezelés} + +A tranzakciók közötti egymásra hatás az adatbázis inkonzisztenssé válását okozhatja, még akkor is, amikor a tranzakciók külön-külön +megőrzik a konzisztenciát és rendszerhiba sem történt. Ezért valamiképpen szabályoznunk kell, hogy a különböző tranzakciók egyes +lépései milyen sorrendben következzenek egymás után. Ezt az ütemező végzi, magát a folyamatot pedig konkurenciavezérlésnek hívjuk. + +Az alapfeltevésünk (helyességi elv), hogy ha minden egyes tranzakciót külön hajtunk végre, akkor azok megőrzik a konzisztens +adatbázis-állapotot. A gyakorlatban viszont a tranzakciók általában konkurensen futnak, ezért a helyességi elv nem +alkalmazható közvetlenül. Így olyan ütemezéseket kell tekintenünk, amelyek biztosítják, hogy ugyanazt az eredményt állítják elő, +mintha a tranzakciókat egymás után, egyesével hajtottuk volna végre. + +\subsubsection{Ütemezések} + +\noindent \textbf{Ütemezés}: Az ütemezés egy vagy több tranzakció által végrehajtott lényeges műveletek időrendben vett +sorozata. Az ütemezéseknél csak az írási és olvasási műveletekkel foglalkozunk.\\ + +\noindent \textbf{Soros ütemezés}: Egy ütemezés soros, ha bármely $T$ és $T'$ tranzakcióra, ha $T$-nek van olyan művelete, amely +megelőzi $T'$ valamely műveletét, akkor $T$ minden művelete megelőzi $T'$ minden műveletét. A soros ütemezést a tranzakciók +felsorolásával adjuk meg, pl. ($T_{1},T_{2}$).\\ + +\noindent \textbf{Sorbarendezhetőség}: Egy ütemezés sorba rendezhető, ha ugyanolyan hatással van az adatbázis állapotára, +mint valamelyik soros ütemezés, függetlenül az adatbázis kezdeti állapotától.\\ + +\noindent \textbf{Jelölések}: +\begin{itemize} + \item $w_{i}(x)$ azt jelenti, hogy a $T_{i}$ tranzakció írja az $x$ adatbáziselemet. + \item $r_{i}(x)$ azt jelenti, hogy a $T_{i}$ tranzakció olvassa az $x$ adatbáziselemet. +\end{itemize} + +\noindent \textbf{Konfliktus}: Konfliktus akkor van, ha van olyan egymást követő műveletpár az ütemezésben, amelynek ha a sorrendjét felcseréljük, akkor legalább az egyik tranzakció viselkedése megváltozik. Tegyük fel, hogy $T_{i}$ és $T_{j}$ különböző tranzakciók. +Ekkor nincs konfliktus, ha a pár: +\begin{itemize} + \item $r_{i}(X)$ és $r_{j}(Y)$, még akkor sem, ha $X = Y$. Azaz 2 különböző tranzakció által végrehajtott olvasási művelet + sosem áll konfliktusban egymással, még akkor sem, ha ugyanarra az adatbázis-elemre vonatkoznak. + + \item $r_{i}(X)$ és $w_{j}(Y)$, ha $X \not = Y$ + + \item $w_{i}(X)$ és $r_{j}(Y)$, ha $X \not = Y$ + + \item $w_{i}(X)$ és $w_{j}(Y)$, ha $X \not = Y$ +\end{itemize} + +\noindent Konfliktus van, ha: +\begin{itemize} + \item Ugyanannak a tranzakciónak bármely két művelete konfliktusban van, hiszen ezek nem cserélhetőek fel. + \item Ugyanazt az adatbáziselemet két különböző tranzakció éri el, és ezek közül legalább az egyik írási művelet. +\end{itemize} + +Tehát különböző tranzakciók műveletei nincsenek konfliktusban egymással, azaz felcserélhetőek, hacsak nem +\begin{enumerate} + \item ugyanarra az adatbáziselemre vonatkoznak, és + \item legalább az egyik művelet írás +\end{enumerate} + +\noindent \textbf{Konfliktusekvivalens ütemezések}: Két ütemezés konfliktusekvivalens, ha szomszédos műveletek nem konfliktusos +cseréjével egymásba vihetők.\\ + +\noindent \textbf{Konfliktus-sorbarendezhető ütemezések}: Egy ütemezés konfliktus-sorbarendezhető, ha konfliktusekvivalens valamely +soros ütemezéssel. A konfliktus-sorbarendezhetőség elégséges, de nem szükséges feltétele a sorbarendezhetőségnek. Piaci rendszerekben +a konfliktus-sorbarendezhetőséget ellenőrzik.\\ + +\noindent \textbf{Megelőzési gráf}: Adott a $T_{1}$ és $T_{2}$ tranzakcióknak, esetleg további tranzakcióknak is, egy $S$ ütemezése. +$T_{1}$ megelőzi $T_{2}$-t S-ben, ha van a $T_{1}$-ben olyan $A_{1}$ művelet és $T_{2}$-ben olyan $A_{2}$ művelet, melyekre: +\begin{enumerate} + \item $A_{1}$ megelőzi $A_{2}$-t $S$-ben, + \item $A_{1}$ és $A_{2}$ ugyanarra az adatbáziselemre vonatkoznak, és + \item legalább az egyik írási művelet +\end{enumerate} +Ezek pont azok a feltételek, amikor $A_{1}$ és $A_{2}$ konfliktusban vannak, nem cserélhetőek fel. Ezeket a megelőzéseket megelőzési +gráffal szemléltethetjük. A megelőzési gráf csomópontjai S-beli tranzakciók. Ha a tranzakciókat $T_{i}$-vel jelöljük, legyen $i$ +a $T_{i}$-hez tartozó csomópont a gráfban. Az $i$ csomópontból $j$ csomópontba megy irányított él, ha $T_{i}$ megelőzi $T_{j}$-t.\\ + +\noindent \textbf{Megelőzési gráf és a konfliktus-sorbarendezhetőség kapcsolata}: Egy $S$ ütemezés konfliktus-sorbarendezhető +akkor és csak akkor, ha megelőzési gráfja körmentes. Ekkor a megelőzési gráf csúcsainak bármely topologikus rendezése megad +egy konfliktus-ekvivalens soros ütemezést. + +\subsubsection{Zárak} + +Zárak használatával is elérhető a konfliktus-sorbarendezhetőség. Ha az ütemező zárakat használ, akkor a tranzakcióknak zárakat +kell kérniük és feloldaniuk az adatbáziselemek olvasásán és írásán felül. A zárak használatának két értelemben is helyesnek kell +lennie: + +\begin{itemize} + \item Tranzakciók konzisztenciája: A műveletek és a zárak az alábbi elvárások szerint kapcsolódnak egymáshoz: + \begin{enumerate} + \item A tranzakció csak akkor olvashat vagy írhat egy elemet, ha már korábban zárolta azt, és még nem oldotta + fel a zárat. + + \item Ha egy tranzakció zárol egy elemet, akkor azt később fel kell szabadítania. + \end{enumerate} + + \item Az ütemezések jogszerűsége: A zárak értelme feleljen meg a szándék szerinti elvárásnak: nem zárolhatja két tranzakció + ugyanazt az elemet, csak úgy, ha az egyik előbb már feloldotta a zárat. +\end{itemize} + +\noindent \textbf{Jelölések}: +\begin{itemize} + \item $l_{i}(x)$: A $T_{i}$ tranzakció zárat kér az $x$ adatbáziselemre. + \item $u_{i}(x)$: A $T_{i}$ tranzakció az $x$ adatbáziselem zárolását feloldja. +\end{itemize} + +\noindent \textbf{Zárolási ütemező}: A zárolási ütemező feladata, hogy akkor és csak akkor engedélyezze a kéréseket, ha +az jogszerű ütemezést eredményez. Ebben segít a zártábla, amely minden adatbáziselemhez megadja azt a tranzakciót, feltéve, hogy +van ilyen, amelyik éppen zárolja az adott elemet.\\ + +\noindent \textbf{Kétfázisú zárolás}: Kétfázisú zárolásról (2FZ) beszélünk, ha minden tranzakcióban minden zárolási művelet +megelőz minden feloldási műveletet. Azok a tranzakciók, amelyek eleget tesznek 2FZ-nek, 2FZ tranzakcióknak nevezzük. Konzisztens, +2FZ tranzakciók jogszerű ütemezése konfliktus-sorbarendezhető.\\ + +\noindent \textbf{Holtpont}: Holtpontról beszélünk, ha az ütemező arra kényszerít egy tranzakciót, hogy örökké várjon egy olyan +zárra, amelyet egy másik tranzakció tart zárolva. Tipikus példa holtpont kialakulására, ha 2 tranzakció egymás által zárolt +elemeket akar zárolni. A kétfázisú zárolás nem tudja megakadályozni holtpontok kialakulását. + +\begin{figure}[H] + \centering + \includegraphics[width=0.5\linewidth]{img/deadlock} + \caption{Példa holtpontra.} + \label{fig:deadlock} +\end{figure} + +\paragraph{Különböző zármódú zárolási rendszerek} + +\noindent \textbf{Osztott és kizárolagos zárak}: Tetszőleges adatbáziselemet vagy egyszer lehet zárolni kizárólagosan (írásra), vagy +többször osztottan (olvasásra). Kizárólagosan zárolt elemet nem lehet osztottan zárolni, illetve osztottan zárolt elemet +nem lehet kizárólagosan zárolni. Ha X-et írni akarjuk, akkor X-re kizárólagos zárral kell rendelkeznünk, ha olvasni, akkor +elég az osztott is, de kizárólagos zárral is tudjuk olvasni.\\ + +\noindent \textbf{Kompatibilitási mátrix}: A kompatibilitási mátrix minden egyes zármódhoz rendelkezik egy sorral és egy oszloppal. +A sorok egy másik tranzakció által az X elemre már érvényes záraknak felelnek meg, az oszlopok pedig az X-re kért zármódoknak +felelnek meg. A használat szabálya: C módú zárat akkor és csak akkor engedélyezhetünk, ha táblázat minden olyan R sorára, amelyre +más tranzakció már zárolta X-et R módban, a C oszlopban "Igen" szerepel. + +\begin{figure}[H] + \centering + \includegraphics[width=0.5\linewidth]{img/kompmatrix} + \caption{Osztott és kizárólagos zárak kompatibilitási mátrixa.} + \label{fig:kompmatrix} +\end{figure} + +\end{document} \ No newline at end of file diff --git a/19.Adatbázisok optimalizálása és konkurencia kezelése/img/db_felepites.png b/21. Adatbázisok optimalizálása és konkurencia kezelése/img/db_felepites.png similarity index 100% rename from 19.Adatbázisok optimalizálása és konkurencia kezelése/img/db_felepites.png rename to 21. Adatbázisok optimalizálása és konkurencia kezelése/img/db_felepites.png diff --git a/19.Adatbázisok optimalizálása és konkurencia kezelése/img/deadlock.png b/21. Adatbázisok optimalizálása és konkurencia kezelése/img/deadlock.png similarity index 100% rename from 19.Adatbázisok optimalizálása és konkurencia kezelése/img/deadlock.png rename to 21. Adatbázisok optimalizálása és konkurencia kezelése/img/deadlock.png diff --git a/19.Adatbázisok optimalizálása és konkurencia kezelése/img/kompmatrix.png b/21. Adatbázisok optimalizálása és konkurencia kezelése/img/kompmatrix.png similarity index 100% rename from 19.Adatbázisok optimalizálása és konkurencia kezelése/img/kompmatrix.png rename to 21. Adatbázisok optimalizálása és konkurencia kezelése/img/kompmatrix.png diff --git a/19.Adatbázisok optimalizálása és konkurencia kezelése/img/querycompiling.png b/21. Adatbázisok optimalizálása és konkurencia kezelése/img/querycompiling.png similarity index 100% rename from 19.Adatbázisok optimalizálása és konkurencia kezelése/img/querycompiling.png rename to 21. Adatbázisok optimalizálása és konkurencia kezelése/img/querycompiling.png diff --git a/19.Adatbázisok optimalizálása és konkurencia kezelése/img/queryprocessing.png b/21. Adatbázisok optimalizálása és konkurencia kezelése/img/queryprocessing.png similarity index 100% rename from 19.Adatbázisok optimalizálása és konkurencia kezelése/img/queryprocessing.png rename to 21. Adatbázisok optimalizálása és konkurencia kezelése/img/queryprocessing.png diff --git a/22. Funkcionális programozás/22. Funkcionális programozás.pdf b/22. Funkcionális programozás/22. Funkcionális programozás.pdf new file mode 100644 index 0000000..47808dd Binary files /dev/null and b/22. Funkcionális programozás/22. Funkcionális programozás.pdf differ diff --git a/22. Funkcionális programozás/22. Funkcionális programozás.tex b/22. Funkcionális programozás/22. Funkcionális programozás.tex new file mode 100644 index 0000000..d97852f --- /dev/null +++ b/22. Funkcionális programozás/22. Funkcionális programozás.tex @@ -0,0 +1,65 @@ +\documentclass[margin=0px]{article} + +\usepackage{listings} +\usepackage[utf8]{inputenc} +\usepackage{graphicx} +\usepackage{float} +\usepackage[a4paper, margin=0.7in]{geometry} +\usepackage{amsthm} +\usepackage{fancyhdr} +\usepackage{setspace} + +\onehalfspacing + +\renewcommand{\figurename}{ábra} +\newenvironment{tetel}[1]{\paragraph{#1 \\}}{} + +\pagestyle{fancy} +\lhead{\it{PTI BSc Záróvizsga tételek}} +\rhead{22. Funkcionális programozás} + +\title{\textbf{{\Large ELTE IK - Programtervező Informatikus BSc} \vspace{0.2cm} \\ {\huge Záróvizsga tételek}} \vspace{0.3cm} \\ 22. Funkcionális programozás} +\author{} +\date{} + +\begin{document} +\maketitle + +\begin{tetel}{Funkcionális programozás} + Funkcionális programozási nyelvek jellemzői: lusta és mohó kiértékelési stratégiák jellemzése és összehasonlítása, hivatkozási helyfüggetlenség, statikus típusozottság, Curry-féle elv, margó szabály, alaptípusok, konverziók, függvények definiálása és típusozása, mintaillesztés, őrfeltételek, esetszétválasztás, rekurzió, lokális definíciók, magasabbrendű függvények, névtelen függvények, függvénykompozíció, halmazkifejezések, típusosztályok, parametrikus (paraméteres) és ad-hoc polimorfizmus, típusszinonimák, algebrai adattípusok definiálása. +\end{tetel} + +\section{Lusta és mohó kiértékelés} +A funkcionális nyelvek kifejezés kiértékelése lehet lusta (lazy), vagy mohó (strict). A lusta kiértékelés során a függvények argumentumai csak akkor értékelődnek ki, ha azokra feltétlenül szükség van. A Clean ilyen lusta kiértékelést alkalmaz, míg az Erlang inkább a szigorú nyelvek közé tartozik. A mohó kiértékelés minden esetben kiértékeli a kifejezéseket, mégpedig olyan hamar, ahogyan az lehetséges. A lusta kiértékelés a inc 4+1 kifejezést elsőként (4+1)+1 kifejezésként interpretálná, míg a mohó rendszer azonnal 5 + 1 formára hozná. + +\section{Hivatkozási helyfüggetlenség} +A kifejezések értéke nem függ attól, hogy a program szövegében hol fordulnak elő, vagyis bárhol helyezzük el ugyanazt a kifejezést, az eredménye ugyanaz marad. Ez a tisztán funkcionális nyelvekre igaz leginkább, ahol a függvényeknek nincs mellékhatása, így a kiértékelésük során sem változtatják meg az adott kifejezést. + +\section{Statikus típusrendszer} +A statikus típusrendszerekben nem kötelező a deklarációk megadása, de követelmény, hogy a kifejezés legáltalánosabb típusát a fordítóprogram minden esetben ki tudja következtetni. A statikus rendszer alapja a Hindley-Milner polimorfikus típusrendszer. + +Természetesen a típusok megadásának az elhagyhatósága nem azt jelenti, hogy azok nincsenek jelen az adott nyelvben. Igenis vannak típusok, csak a kezelésükről, valamint a kifejezések helyes kiértékeléséről a típuslevezető rendszer és a fordítóprogram gondoskodik. + +\section{Curry-féle elv} +A Curry módszer a részleges függvény alkalmazás, ami azt jelenti, hogy a több paraméteres függvények visszatérési értéke lehet egy függvény és a maradék paraméterek. Ez alapján minden függvény tekinthető egyváltozós függvénynek. Amennyiben a függvénynek két változója van, akkor csak az egyiket tekintjük a függvényhez tartozó paraméternek. A paraméter megadása egy új egyváltozós függvényt hoz létre, amit alkalmazhatunk a második változóra. A módszer több változó esetén is működőképes. Erlangban és F\#-ban nincs ilyen nyelvi elem, de a lehetősége adott. Készítéséhez függvény kifejezést használhatunk. + +\section{Margó szabály} +Összetartozó kifejezések csoportjának azonosítására és deklarációk hatáskörének korlátozására alkalmas a bal oldali margó szélességének változtatása. + +\section{Alaptípusok} +TODO + +\section{Mintaillesztés} +A mintaillesztés függvényekre alkalmazva azt jelenti, hogy a függvény több ággal rendelkezhet, és az egyes ágakhoz (clause) a formális paraméterek különböző mintáit rendelhetjük hozzá. A függvény hívásakor mindig az az ág fut le, amelynek a formális paramétereire a híváskor megadott aktuális paraméterek illeszkednek. Az OO nyelvekben az ilyen függvényeket overload függvénynek nevezzük. A mintaillesztés alkalmazható változók, és listák mintaillesztése esetén is, valamint elágazások ágainak (branch) a kiválasztására. + +\section{Magasabbrendű függvények} +Funkcionális nyelvekben lambda-kifejezéseket, vagyis speciálisan leírt függvényeket adhatunk át más függvények paraméter listájában. Természetesen nem a függvényhívás kerül a paraméterek közé, hanem a függvény prototípusa. + +Számos programozási nyelv lehetőséget ad arra, hogy változókba kössük a lambda-függvényeket, majd az így megkonstruált változókat később függvényként használjuk. A lambda-kifejezéseket elhelyezhetjük lista-kifejezésekben is. A függvénnyel való paraméterezés segítségünkre van abban, hogy teljesen általános függvényeket, vagy programokat hozzunk létre, ami kifejezetten hasznos szerver alkalmazások készítésekor. + +\section{Halmazkifejezések} +A különböző nyelvi konstrukciók mellett a funkcionális nyelvekben számos különleges adattípust is találunk, mint a rendezett n-es, vagy ismertebb nevén a tuple, valamint a halmazkifejezések, és az ezekhez konstruálható lista generátorok. A lista adattípus a Zermelo-Fraenkel féle halmazkifejezésen alapul. Tartalmaz egy generátort, amely az elemek listába tartozásának feltételét írja le, valamint azt, hogy a lista egyes elemeit hogyan, és milyen számban kell előállítani. Ezzel a technológiával elvben végtelen listát is képesek vagyunk leírni az adott programozási nyelven, mivel nem a lista elemeit, hanem a lista definícióját írjuk le. + + + +\end{document} \ No newline at end of file diff --git a/3. Numerikus módszerek/3. Numerikus módszerek.pdf b/3. Numerikus módszerek/3. Numerikus módszerek.pdf new file mode 100644 index 0000000..d6aa60d Binary files /dev/null and b/3. Numerikus módszerek/3. Numerikus módszerek.pdf differ diff --git a/3. Numerikus módszerek/3. Numerikus módszerek.tex b/3. Numerikus módszerek/3. Numerikus módszerek.tex new file mode 100644 index 0000000..38e5a7a --- /dev/null +++ b/3. Numerikus módszerek/3. Numerikus módszerek.tex @@ -0,0 +1,482 @@ +\documentclass[margin=0px]{article} + +\usepackage{listings} +\usepackage[utf8]{inputenc} +\usepackage{graphicx} +\usepackage{float} +\usepackage[a4paper, margin=0.7in]{geometry} +\usepackage{amsthm} +\usepackage{amssymb} +\usepackage{amsmath} +\usepackage{fancyhdr} +\usepackage{setspace} +\usepackage{pdfpages} + +\onehalfspacing + +\newenvironment{tetel}[1]{\paragraph{#1 \\}}{} + +\pagestyle{fancy} +\lhead{\it{PTI BSc Záróvizsga tételek}} +\rhead{3. Numerikus módszerek} + +\title{\textbf{{\Large ELTE IK - Programtervező Informatikus BSc} \vspace{0.2cm} \\ {\huge Záróvizsga tételek}} \vspace{0.3cm} \\ 3. Numerikus módszerek} +\author{} +\date{} + +\begin{document} +\maketitle + +\begin{tetel}{Numerikus módszerek} + Nemlineáris egyenletek iterációs módszerei: fixpont iterációk, Newton iteráció. Interpoláció: Lagrange- és Newton-féle alak. Legkisebb négyzetek módszere. Numerikus integrálás: interpolációs formulák, Newton-Cotes formulák, egyszerű és összetett formulák. +\end{tetel} + +\section{Nemlineáris egyenletek iterációs módszerei} + +Eddig egyenletrendszerekkel foglalkoztunk, melyekben minden egyenlet lineáris volt. Most módszereket +fogunk keresni az $f(x) = 0$ típusú egyenletek megoldására, ahol $f \in \mathbb{R} \to \mathbb{R}$. A módszerek +lényege az lesz, hogy valamilyen szempont szerint egy számsorozatot állítunk elő, melyek bizonyos +feltételek mellett az egyenlet gyökéhez konvergálnak.\\ + +\noindent \textbf{Bolzano-tétel}: Legyen $f \in C[a,b]$ és $f(a)f(b) <0$, azaz az $f$ függvény az $a$ és $b$ +pontokban nem $0$, valamint ellenkező előjelű. Ekkor létezik $(a,b)$ intervallumbeli gyöke az $f$-nek, azaz +$\exists x^{*} \in (a,b): f(x^{*}) = 0$.\\ + +\noindent \textbf{A Bolzano-tétel következménye}: Ha a Bolzano-tétel feltételei mellett még $f$ szigorúan monoton is, akkor +az $x^{*}$ egyértelműen létezik (hiszen $f$ invertálható).\\ + +\noindent \textbf{Brouwer-féle fixponttétel}: Legyen $f : [a,b] \to [a,b]$ és $f \in C[a,b]$. Ekkor $\exists + x^{*} \in [a,b]: x^{*} = f(x^{*})$.\\ + +\noindent \textbf{Tétel}: Legyen $f : [a,b] \to [a,b]$, $f \in C^{1}[a,b]$ és $f'$ állandó előjelű. Ekkor $\exists! + x^{*} \in [a,b]: x^{*} = f(x^{*})$.\\ + +\noindent \textbf{Fixponttétel [a,b]-re}: Legyen $f : [a,b] \to [a,b]$ kontrakció a $q$ kontrakciós együtthatóval. +Ekkor: + +\begin{enumerate} + \item $\exists! x^{*} \in [a,b]: x^{*} = f^{x*}$, + + \item $\forall x_{0} \in [a,b]: x_{k+1} = f(x_{k})$ konvergens és $x^{*} = \lim\limits_{k \to \infty} x_{k}$, + + \item $| x_{k} - x^{*} | \leq q^{k} | x_{0} - x^{*}| \leq q^{k}(b-a)$. +\end{enumerate} + +\noindent \textbf{p-adrendű konvergencia}: Az $(x_{k})$ konvergens sorozat ($\lim\limits_{k \to \infty} x_{k} = x^{*}$) +$p$-adrendben konvergens, ha + +\begin{displaymath} + \lim\limits_{k \to \infty} \frac{|x_{k+1} - x^{*}|}{|x_{k}-x^{*}|^{p}} = c > 0 +\end{displaymath} + +\noindent Néhány megjegyzés a fenti definícióhoz: + +\begin{enumerate} + \item $p$ egyértelmű és $p \geq 1$ + + \item $p=1$ esetén lineáris $p=2$ esetén kvadratikus, $1 < p < 2$ esetén szuperlineáris + + \item A gyakorlatban az $|x_{k+1} - x^{*}| \leq M|x_{k} - x^{*}|^{p}$ alakot használják, azt jelenti, hogy + legalább $p$-adrendben konvergens. +\end{enumerate} + +\noindent \textbf{Tétel}: Tegyük fel, hogy az $(x_{k})$ sorozat konvergens, +$x_{k+1} = f(x_{k})$ és $f'(x^{*}) = f''(x^{*}) = ... = f^{(p-1)}(x^{*}) = 0$, de $f^{(p)}(x^{*}) \not = 0$. +Ekkor az $(x_{k})$ $p$-adrendben konvergens. + +\subsubsection{Newton-módszer} + +\begin{figure}[H] + \centering + \includegraphics[width=0.6\linewidth]{img/newton_pelda} + \caption{A Newton-módszer ötlete.} + \label{fig:newton_pelda} +\end{figure} + +Az ábrán a legszélső, 4.12-es pontból indulunk, felvesszük a függvény ehhez a ponthoz tartozó +érintőjét, majd ennek az érintőnek a gyöke lesz a következő pont, és így tovább. Általánosan, +tekintsük az $f$ függvény $x_{k}$ ponthoz tartozó érintőjének egyenletét: + +\begin{displaymath} + y - f(x_{k}) = f'(x_{k}) (x-x_{k}) +\end{displaymath} + +\noindent Mint mondtuk, az iteráció $x_{k+1}$. elemét az $x_{k}$-hoz tartozó érintő gyöke adja meg: + +\begin{displaymath} + 0 - f(x_{k}) = f'(x_{k}) (x_{k+1}-x_{k}) \Rightarrow + - \frac{f(x_{k})}{f'(x_{k})} = x_{k+1} - x_{k} \Rightarrow + x_{k+1} = x_{k} - \frac{f(x_{k})}{f'(x_{k})} +\end{displaymath} + +A fenti képlet a Newton-módszer képlete. Megjegyezhető, hogy a fenti módszer is $x_{k+1} = g(x_{k})$ +alakú (fixpontiteráció). + +Fontos megemlíteni, hogy $f'(x_{k}) = 0$ esetén nem értelmezhető a módszer. A gyakorlatban $f'(x_{k}) \approx 0$ is probléma. +Ha $x^{*}$ többszörös gyök, akkor $f'(x^{*}) = 0$, vagyis $x^{*}$ közelében $f'(x_{k})$ egyre jobban közelít $0$-hoz, numerikusan +instabil.\\ + +\noindent \textbf{Monoton konvergencia tétele}: Tegyük fel, hogy $f \in C^{2}[a,b]$ és +\begin{enumerate} + \item $\exists x^{*} \in [a,b] : f(x^{*}) = 0$, azaz van gyök + + \item $f'$ és $f''$ állandó előjelű + + \item $x_{0} \in [a,b]$ legyen olyan, hogy $f(x_{0}) f''(x_{0})) >0$, azaz $f(x_{0}) \not = 0$, valamint $f(x_{0})$ és $f''(x_{0})$ + azonos előjelűek +\end{enumerate} + +\noindent Ekkor az $x_{0}$-ból indított Newton-módszer monoton konvergál $x^{*}$-hoz. + +\noindent \textbf{Lokális konvergencia tétele}: Tegyük fel, hogy $f \in C^{2}[a,b]$ és +\begin{enumerate} + \item $\exists x^{*} \in [a,b] : f(x^{*}) = 0$, azaz van gyök + + \item $f'$ állandó előjelű + + \item $00$ úgy, hogy +$M_{n} \leq M^{n} \ \forall n \in \mathbb{N}$, akkor az $L_{n}$ sorozat egyenletesen konvergál az $f$ függvényhez.\\ + +\noindent \textbf{Marcinkiewicz tétele}: Minden $f \in C[a,b]$ esetén létezik a fenti módon definiált alappontrendszer +úgy, hogy $\Vert f - L_{n}\Vert_{\infty} \to 0$.\\ + +\noindent \textbf{Faber tétele}: Minden a fenti módon definiált alappontrendszer esetén van olyan $f \in C[a,b]$ függvény, +hogy $\Vert f - L_{n}\Vert_{\infty} \not \to 0$.\\ + +\noindent \textbf{Osztott differencia}: Legyenek adva az $x_{k} \in [a,b], k=0,1,...,n$ különböző alappontok. +Az $f:[a,b] \to \mathbb{R}$ függvénynek a megadott alappontrendszerre vonatkozó elsőrendű osztott differenciái + +\begin{displaymath} + f[x_{i},x_{i+1}] = \frac{f(x_{i+1})-f(x_{i})}{x_{i+1} - x_{i}} +\end{displaymath} + +\noindent a magasabb rendű osztott differenciákat rekurzívan definiáljuk. Tegyük fel, hogy a $k-1$ rendű osztott differenciák +már definiálva lettek, akkor a $k$-adrendű osztott differenciák az alábbiak: + +\begin{displaymath} + f[x_{i},x_{i+1},...,x_{i+k}] = \frac{f[x_{i+1},x_{i+2}, ..., x_{i+k}]-f[x_{i},x_{i+1}, ..., x_{i+k-1})]}{x_{i+k} - x_{i}} +\end{displaymath} + +\noindent Látható, hogy a $k$-adrenű osztott differencia $k+1$ alappontra támaszkodik.\\ + +Ha adott egy interpoláció alappontrendszer függvényértékekkel, akkor a hozzá tartozó osztott differenciákat az +alábbi táblázat szerint érdemes elrendezni, és ez az elrendezés egyúttal a kiszámolást is segíti. + +\begin{table}[H] + \begin{tabular}{llllllll} + $x_{0}$ & $f(x_{0})$ & & & & & & \\ + $x_{1}$ & $f(x_{1})$ & $f[x_{0},x_{1}]$ & & & & & \\ + $x_{2}$ & $f(x_{2})$ & $f[x_{1},x_{2}]$ & & & & & \\ + \rotatebox[origin=c]{90}{...} & \rotatebox[origin=c]{90}{...} & & & & & & \\ + $x_{k}$ & $f(x_{k})$ & $f[x_{k-1},x_{k}]$ & ... & $f[x_{0}, x_{1}, ..., x_{k}]$ & & & \\ + \rotatebox[origin=c]{90}{...} & \rotatebox[origin=c]{90}{...} & & & & & & \\ + $x_{n-1}$ & $f(x_{n-1})$ & $f[x_{n-2},x_{n-1}]$ & ... & $f[x_{n-1-k}, x_{n-k}, ..., x_{n-1}]$ & ... & + $f[x_{0}, x_{1}, ..., x_{n-1}]$ & \\ + $x_{n} $ & $f(x_{n})$ & $f[x_{n-1},x_{n}]$ & ... & $f[x_{n-k}, x_{n-k+1}, ..., x_{n}]$ & ... & + $f[x_{1}, x_{2}, ..., x_{n}]$ & $f[x_{0}, x_{1}, ..., x_{n}]$ \\ + \end{tabular} +\end{table} + + +\noindent \textbf{Az interpolációs polinom Newton-alakja}: Az interpolációs polinom az alábbi alakban felírható: +\begin{displaymath} + N_{n}(x) = f(x_{0}) + \displaystyle\sum_{k=1}^{n}f[x_{0},x_{1}, ..., x_{k}] \omega_{k-1}(x) +\end{displaymath} + +\noindent ahol $\omega_{j}(x) = (x-x_{0})(x-x_{1})...(x-x_{j})$. Ezt az alakot az interpolációs polinom Newton-alakjának hívjuk. + +\subsubsection{Hermite-interpoláció} +Az előbbi interpolációs feladatot a következőképpen általánosíthatjuk. Legyenek adva az egyes alappontokban a függvényértékek +mellett a függvény derivált értékei is valamely rendig bezárólag. Ekkor olyan polinomot keresünk, amelyik deriváltjaival együtt +illeszkedik a megadott értékekre, vagyis:\\ + +\noindent Legyenek adva $n,m_{0},m_{1},..., m_{n} \in \mathbb{N}$ és az $x_{j} \in \mathbb{R}, j=0,1,...,n$ interpolációs +alappontok, valamint az $f^{(k)}(x_{j}) \ \ k=0,1,...,m_{j}-1, \ \ \ j=0,1,...,n$ függvény- és derivált értékek. Legyen +$m = \displaystyle\sum_{j=0}^{n}m_{j}$ Keressük azt a legfeljebb ($m-1$)-edfokú $p_{m-1}$ polinomot, melyre: + +\begin{displaymath} + p^{(k)}_{m-1}(x_{j}) = f^{(k)}(x_{j}) \ \ k=0,1,...,m_{j}-1, \ \ \ j=0,1,...,n +\end{displaymath} + +\noindent \textbf{Megjegyzések}: +\begin{enumerate} + \item Ha $m_{j}=2, j=0,1,...,n$, akkor a feladatot Hermite-Fejér-féle interpolációnak nevezzük. Ekkor minden alappontban + a függvény- és az első derivált érték adott. A keresett polinom pedig legfeljebb ($2n+1$)-edfokú. + + \item Ha $m_{j}=1, j=0,1,...,n$, akkor a Lagrange-interpolációt kapjuk vissza. +\end{enumerate} + +\noindent \textbf{Osztott differencia ismétlődő allapontokra}: Ha $x_{k}$ $j$-szer szerepel: +\begin{displaymath} + f[x_{k}, ... x_{k}] = \frac{f^{(j)}(x_{k})}{j!} +\end{displaymath} + +\noindent \textbf{Tétel}: A Hermite-féle interpolációs polinom egyértelműen létezik.\\ + +\noindent \textbf{A Hermite interpolációs polinom előállítása}: Könnyen felírható a Newton-féle formában. Csak annyit +kell tennünk, hogy kiindulunk az alappontok és a függvényértékek táblázatával és legyártjuk az osztott differenciák +táblázatát. Az az egyetlen különbség most, hogy az $x_{j}$ alappontot $m_{j}$-szer soroljuk fel.\\ + +\noindent \textbf{Hermite-interpoláció hibája}: Ha $f \in C^{m}[a,b]$, akkor $\forall x \in [a,b]:$ + +\begin{displaymath} + |f(x) - H_{m-1}(x)| \leq \frac{M_{m}}{m!}|\Omega_{m}(x)| +\end{displaymath} + +\noindent ahol $\Omega_{m}(x) = (x-x_{0})^{m_{0}}(x-x_{1})^{m_{1}}...(x-x_{n})^{m_{n}}$ + +\section{Legkisebb négyzetek módszere} + +Gyakorlati feladatok során adódik a következő probléma. Egy elsőfokú függvényt mérünk bizonyos pontokban, de +a mérési hibák miatt ezek nem lesznek egye egyenesen. Ekkor olyan egyenest keresünk, amelyik az alábbi +értelemben legjobban illeszkedik a megadott mérési ponthalmazra. + +Legyenek adva az $(x_{i},y_{i}), i=1,2,..,m$ mérési pontok. Keressük azt a $p_{1}(x) = a + bx$ legfeljebb +elsőfokú polinomot, amelyre a + +\begin{displaymath} + \displaystyle\sum_{i=1}^{m}(y_{i}-p_{1}(x_{i}))^{2} = + \displaystyle\sum_{i=1}^{m}(y_{i}- a - bx_{i})^{2} +\end{displaymath} + +\noindent kifejezés minimális. Ez azt jelenti, hogy azt az egyenes keressük, amelyre a függvényértékek hibáinak +négyzetösszege minimális. + +Az általános feladat az alábbi. + +Adottak az $m,n \in \mathbb{N}$, ahol $m >> n$ és $(x_{i},y_{i}), i= 1,2,...,m$ mérési pontok, ahol az $x_{i}$ +alappontok különbözők. Keressük azt a $p_{n}(x) = a_{0} + a_{1}x + ... a_{n}x^{n}$ legfeljebb $n$-edfokú +polinomot, melyre a + +\begin{displaymath} + \displaystyle\sum_{i=1}^{m}(y_{i}-p_{n}(x_{i}))^{2} +\end{displaymath} + +\noindent kifejezés minimális. + +A feladat megoldásához tekintsük annak egy átfogalmazását. + +Vegyük a $p_{n}(x_{i}) = y_{i}, i=1,2,...,m)$ egyenletrendszert. Ez a rendszer az ismeretlen $a_{i}$ együtthatókra nézve +lineáris, mégpedig túlhatározott, amelynek az $A$ mátrixa egy téglalap alakú Vandermonde-mátrix $A \in \mathbb{R}^{m \times (n+1)}$, +a $b \in \mathbb{R}^{m}$ jobb oldali vektora pedig a függvényértékekből adódik: + +\begin{displaymath} + \begin{bmatrix} + 1 & x_{1} & x_{1}^{2} & ... & x_{1}^{n} \\[0.3em] + 1 & x_{2} & x_{2}^{2} & ... & x_{2}^{n} \\[0.3em] + 1 & x_{3} & x_{3}^{2} & ... & x_{3}^{n} \\[0.3em] + \rotatebox[origin=c]{90}{...} & \rotatebox[origin=c]{90}{...} & \rotatebox[origin=c]{90}{...} & \rotatebox[origin=c]{90}{...} & \rotatebox[origin=c]{90}{...} \\[0.3em] + 1 & x_{m} & x_{m}^{2} & ... & x_{m}^{n} \\[0.3em] + \end{bmatrix} + \begin{bmatrix} + a_{0} \\[0.3em] + a_{1} \\[0.3em] + a_{2} \\[0.3em] + \rotatebox[origin=c]{90}{...} \\[0.3em] + a_{n} + \end{bmatrix} + = + \begin{bmatrix} + y_{0} \\[0.3em] + y_{1} \\[0.3em] + y_{2} \\[0.3em] + \rotatebox[origin=c]{90}{...} \\[0.3em] + y_{m} + \end{bmatrix} +\end{displaymath} + +Ezen jelölésekkel a minimalizálandó kifejezés $\Vert Az - b \Vert_{2}^{2}$, ahol $z = [a_{0},a_{1}, ..., a_{n}]^{T}$ +a keresett együtthatók vektora. A feladat megoldását a Gauss-féle normálegyenletek adják: + +\begin{displaymath} + A^{T}Az = A^{T}b +\end{displaymath} + +\noindent A fenti LER-t kell megoldani $z$-re.\\ + +\noindent \textbf{n=1 eset}: Ekkor a feladatot gyakran lineáris regressziónak is hívjuk. Ebben az esetben +\begin{displaymath} + A^{T}A = \begin{bmatrix} + m & \sum_{i=1}^{m} x_{i} \\[0.3em] + \sum_{i=1}^{m} x_{i} & \sum_{i=1}^{m} x_{i}^{2} + \end{bmatrix} \ , + A^{T}b = \begin{bmatrix} + \sum_{i=1}^{m} y_{i} \\[0.3em] + \sum_{i=1}^{m} x_{i}y_ {i} + \end{bmatrix} \ , + z= \begin{bmatrix} + b \\[0.3em] + a + \end{bmatrix} +\end{displaymath} + +\section{Numerikus integrálás} + +\includepdf[pages={2-8}]{Numerikus_Integralas.pdf} + +\end{document} \ No newline at end of file diff --git a/3. Numerikus módszerek/3.1 Lineáris egyenletrendszerek interációs módszerei.pdf b/3. Numerikus módszerek/3.1 Lineáris egyenletrendszerek interációs módszerei.pdf new file mode 100644 index 0000000..2193497 Binary files /dev/null and b/3. Numerikus módszerek/3.1 Lineáris egyenletrendszerek interációs módszerei.pdf differ diff --git a/3. Numerikus módszerek/3.1 Lineáris egyenletrendszerek interációs módszerei.tex b/3. Numerikus módszerek/3.1 Lineáris egyenletrendszerek interációs módszerei.tex new file mode 100644 index 0000000..bccfc52 --- /dev/null +++ b/3. Numerikus módszerek/3.1 Lineáris egyenletrendszerek interációs módszerei.tex @@ -0,0 +1,356 @@ +\documentclass[margin=0px]{article} + +\usepackage{listings} +\usepackage[utf8]{inputenc} +\usepackage{graphicx} +\usepackage{float} +\usepackage[a4paper, margin=0.7in]{geometry} +\usepackage{amsthm} +\usepackage{amssymb} +\usepackage{amsmath} +\usepackage{fancyhdr} +\usepackage{setspace} + +\onehalfspacing + +\newenvironment{tetel}[1]{\paragraph{#1 \\}}{} + +\pagestyle{fancy} +\lhead{\it{PTI BSc Záróvizsga tételek}} +\rhead{3.1. Lineáris egyenletrendszerek iterációs módszerei} + +\title{\textbf{{\Large ELTE IK - Programtervező Informatikus BSc} \vspace{0.2cm} \\ {\huge Záróvizsga tételek}} \vspace{0.3cm} \\ 3.1. Lineáris egyenletrendszerek iterációs módszerei} +\author{} +\date{} + +\begin{document} +\maketitle + +\subsection{Lineáris egyenletrendszerek iterációs módszerei} + +A lineáris egyenletrendszert (LER) vektorsorozatokkal közelítjük, törekedve a minél gyorsabb konvergenciára. +Az iterációs módszereknek a lényege az $Ax = b \Longleftrightarrow x = Bx + c$ átalakítás. Ilyen alak létezik, +sőt nem egyértelmű, hanem sokféle lehet, és a különböző átalakítások szolgáltatják a különféle iterációs módszereket.\\ + +\noindent \textbf{Definíció (kontrakció)}: Az $F: \mathbb{R}^{n} \to \mathbb{R}^{n}$ függvény kontrakció, ha +$\exists 0 \leq q < 1 : \forall x,y \in \mathbb{R}^{n}:$ +\begin{displaymath} + \Vert F(x) - F(y) \Vert \leq q \Vert x - y \Vert +\end{displaymath}. + +\noindent A $q$ értéket kontrakciós együtthatónak nevezzük.\\ + +\noindent \textbf{Banach-féle fixponttétel}: Legyen $F: \mathbb{R}^{n} \to \mathbb{R}^{n}$ kontrakció a q +kontrakciós együtthatóval. Ekkor a következő állítások igazak: + +\begin{enumerate} + \item $\exists! x^{*} \in \mathbb{R}^{n}: x^{*} = f(x^{*})$. Azt mondjuk, hogy $x^{*}$ az $f$ függvény + fixpontja. + + \item $\forall x^{(0)} \in \mathbb{R}^{n}$ kezdőérték esetén az $x^{(k+1)} = f(x^{(k)})$ sorozat konvergens, + és $\lim \limits_{k\to\infty} x^{(k)} = x^{*}$. + + \item $\Vert x^{(k)} - x^{*}\Vert \leq \frac{q^{k}}{1-q} \Vert x^{(1)} - x^{0}\Vert$. + + \item $\Vert x^{(k)} - x^{*}\Vert \leq q^{k} \Vert x^{(0)} - x^{*}\Vert$. +\end{enumerate} + +Vegyük észre, hogy az $Ax = b \Longleftrightarrow x = Bx + c$ átírással megteremtettük a kapcsolatot a +Banach-féle fixponttétellel, hisz most az $F(x) = Bx + c$ függvény fixpontját keressük. A fenti felírásban +$B$-t átmenetmátrixnak nevezzük.\\ + +\noindent \textbf{Tétel (elégséges feltétel a konvergenciára)}: Ha a LER $B$ átmenetmátrixára $\Vert B \Vert < 1$, +akkor tetszőleges $x^{(0)}$-ból indított $x^{(k+1)} := Bx^{(k)} + c$ iteráció konvergál az $Ax = b$ LER megoldásához.\\ + +\noindent \textbf{Tétel (Szükséges és elégséges feltétel a konvergenciára)}: Tetszőleges $x^{(0)}$-ból indított +$x^{(k+1)} := Bx^{(k)} + c$ iteráció konvergál az $Ax = b$ LER megoldásához $\Longleftrightarrow$ +$\varrho(B) < 1$, ahol $\varrho(B) = \max_{1 \leq i \leq n} |\lambda_{i}(B)|$ a $B$ mátrix spektrálsugara. + +\subsubsection{Jacobi-iteráció} + +Tekintsük az $A \in \mathbb{R}^{n \times n}$ mátrix $L + D + U$ felbontását, ahol $L$ a mátrix szigorú alsó része, $U$ a +szigorú felső része, $D$ pedig a diagonális része. Ennek segítségével konstruáljuk meg a következő átírást: + +\begin{displaymath} + Ax = b \Longleftrightarrow (L + D + U)x = b \Longleftrightarrow Dx = -(L+U)x+b \Longleftrightarrow + x = -D^{-1}(L+U)x + D^{-1}b +\end{displaymath} + +\noindent A Jacobi-iteráció átmenetmátrixa tehát $B_{J} = -D^{-1}(L + U)$, maga az iteráció pedig: + +\begin{displaymath} + x^{(k+1)} := -D^{-1}(L + U)x^{(k)} + D^{-1}b +\end{displaymath} + +\noindent Koordinátás alakban felírva: + +\begin{displaymath} + x^{(k+1)}_{i} := + -\frac{1}{a_{ii}} + \Bigg[ + \sum_{\substack{j=1\\ j \not = i}}^{n} a_{ij}x_{j}^{(k)} - b_{i} + \Bigg] + \; (i = 1, ..., n) +\end{displaymath} + +\noindent \textbf{Tétel}: Ha az A mátrix szigorúan diagonálisan domináns a soraira, akkor +$\Vert B_{J} \Vert_{\infty} < 1$ (azaz konvergens a módszer).\\ + +\noindent \textbf{Tétel}: Ha az A mátrix szigorúan diagonálisan domináns az oszlopaira, akkor +$\Vert B_{J} \Vert_{1} < 1$ (azaz konvergens a módszer). + +\subsubsection{Csillapított Jacobi-iteráció} + +Továbbra is a Jacobi-iterációval foglalkozunk, csak egy plusz $\omega$ paraméter bevezetésével próbáljuk +finomítani a módszert. Tekintsük a $Dx = -(L + U)x + b$ egyenletet, valamint a triviális $Dx = + Dx$ egyenletet. Ezeket rendre szorozzuk meg $\omega$, illetve $1 - \omega$ értékekkel, majd adjuk össze a két +egyenletet: + +\begin{displaymath} + Dx = (1 - \omega)Dx -\omega(L+U)x + \omega b +\end{displaymath} + +\noindent Szorozzunk $D^{-1}$-zel: + +\begin{displaymath} + x = (1 - \omega)Ix -\omega D^{-1}(L+U)x + \omega D^{-1}b \Longleftrightarrow + x = ((1 - \omega)I -\omega D^{-1}(L+U))x + \omega D^{-1}b +\end{displaymath} + +\noindent Ez alapján $B_{J(\omega)} = (1 - \omega)I -\omega D^{-1}(L+U)$ és $c_{J}(\omega) = \omega D^{-1}b$.\\ + +\noindent Észrevehető, hogy $\omega = 1$ esetén pont a Jacobi-iterációt kapjuk vissza.\\ + +\noindent Koordinátás alakban felírva: + +\begin{displaymath} + x^{(k+1)}_{i} = + (1 - \omega)x^{(k)}_{i} + -\frac{\omega}{a_{ii}} + \Bigg[ + \sum_{\substack{j=1\\ j \not = i}}^{n} a_{ij}x_{j}^{(k)} - b_{i} + \Bigg] + \; (i = 1, ..., n) +\end{displaymath} + +\noindent \textbf{Tétel}: Ha $J(1)$ konvergens, akkor $\omega \in (0,1)$-re $J(\omega)$ is az. + +\subsubsection{Gauss-Seidel iteráció} + +\noindent Egy másik lehetséges iteráció konstruálásának az ötlete a következő: + +\begin{displaymath} + Ax = b \Longleftrightarrow (L + D + U)x = b \Longleftrightarrow (L+D)x = -Ux+b \Longleftrightarrow + x = -(L+D)^{-1}Ux + (L+D)^{-1}b +\end{displaymath} + +\noindent Ez az ötlet szüli a Gauss-Seidel iterációt, vagyis: + +\begin{displaymath} + x^{(k+1)} := -(L+D)^{-1}Ux^{(k)} + (L+D)^{-1}b +\end{displaymath} + +Az iteráció átmenetmátrixa tehát $B_{S} = -(L+D)^{-1}U$. A koordinátás alak felírásához kicsit átírjuk +az iterációt: + +\begin{displaymath} + (L+D)x^{(k+1)} = -Ux^{(k)} + b +\end{displaymath} + +\begin{displaymath} + Dx^{(k+1)} = -Lx^{(k+1)} - Ux^{(k)} + b +\end{displaymath} + +\begin{displaymath} + x^{(k+1)} = -D^{-1} \big[Lx^{(k+1)} + Ux^{(k)} - b \big] +\end{displaymath} + +\begin{displaymath} + x^{(k+1)}_{i} = + -\frac{1}{a_{ii}} + \Bigg[ + \sum_{j=1}^{i-1} a_{ij}x_{j}^{(k+1)} + + \sum_{j=i+1}^{n} a_{ij}x_{j}^{(k)} - + b_{i} + \Bigg] + \; (i = 1, ..., n) +\end{displaymath} + +\noindent \textbf{Megjegyzés}: Az implementáció során elég egyetlen $x$ vektort eltárolni, és annak a komponenseit sorban felülírni, ugyanis +láthatjuk, hogy az első $i-1$ komponenst már az "új", $x^{(k+1)}$ vektorból vesszük.\\ + +\noindent \textbf{Tétel}: Ha $A$ szigorúan diagonálisan domináns +\begin{enumerate} + \item a soraira, akkor + $\Vert B_{S} \Vert_{\infty} \leq \Vert B_{J} \Vert_{\infty} < 1$. + + \item az oszlopaira, akkor + $\Vert B_{S} \Vert_{1} \leq \Vert B_{J} \Vert_{1} < 1$. +\end{enumerate} + +\noindent Azaz a Gauss-Seidel is konvergens, és legalább olyan gyors, mint a Jacobi. + +\subsubsection{Relaxációs módszer} + +A relaxációs módszer lényegében a csillapított Gauss-Seidel iterációt jelenti. Ennek megkonstruálásához +tekintsük az $(L+D)x = -Ux + b$ és $Dx = Dx$ egyenleteket. Ezeket rendre szorozzuk meg $\omega$, illetve +$1 - \omega$ értékekkel, majd adjuk össze a két egyenletet: + +\begin{displaymath} + (D+\omega L)x = (1 - \omega)Dx -\omega Ux + \omega b +\end{displaymath} + +\begin{displaymath} + x = (D+\omega L)^{-1}\big[(1 - \omega)D -\omega U \big]x + \omega (D+\omega L)^{-1}b +\end{displaymath} + +Az iteráció tehát: $x^{(k+1)} = (D+\omega L)^{-1}\big[(1 - \omega)D -\omega U \big]x^{(k)} + \omega (D+\omega L)^{-1}b$, ahol +az átmenetmátrix: $B_{S(\omega)}= (D+\omega L)^{-1}\big[(1 - \omega)D -\omega U \big]$. A koordinátás alak +felírásához itt is átírjuk kicsit az iterációt: + +\begin{displaymath} + (D + \omega L)x^{(k+1)} = (1 - \omega)Dx^{(k)} -\omega Ux^{(k)} + \omega b +\end{displaymath} + +\begin{displaymath} + Dx^{(k+1)} = -\omega Lx^{(k+1)} -\omega Ux^{(k)} + \omega b + (1 - \omega)Dx^{(k)} +\end{displaymath} + +\begin{displaymath} + x^{(k+1)} = -\omega D^{-1} \big[Lx^{(k+1)} + Ux^{(k)} - b \big] + (1 - \omega)x^{(k)} +\end{displaymath} + +\begin{displaymath} + x^{(k+1)}_{i} = + -\frac{\omega}{a_{ii}} + \Bigg[ + \sum_{j=1}^{i-1} a_{ij}x_{j}^{(k+1)} + + \sum_{j=i+1}^{n} a_{ij}x_{j}^{(k)} - + b_{i} + \Bigg] + + (1 - \omega) x_{i}^{(k)} + \; (i = 1, ..., n) +\end{displaymath} + +\noindent Vegyük észre, hogy $\omega = 1$ esetén a Gauss-Seidel iterációt kapjuk.\\ + +\noindent \textbf{Tétel}: Ha a relaxációs módszer konvergens minden kezdővektorból indítva, akkor $\omega \in (0,2)$.\\ + +\noindent \textbf{Megjegyzés}: Ha $\omega \notin (0,2)$, akkor általában nem konvergens a módszer (bár adott feladat esetén előfordulhat, +hogy találunk olyan kezdővektort, amelyből indítva konvergál a módszer).\\ + +\noindent \textbf{Tétel}: Ha $A$ szimmetrikus és pozitív definit és $\omega \in (0, 2)$, akkor a relaxációs módszer konvergens. Ennek +következménye a Gauss-Seidel iteráció konvergenciája ($\omega = 1$ eset).\\ + +\noindent \textbf{Tétel}: Ha $A$ tridiagonális, akkor $\varrho(B_{S}) = \varrho(B_{J})^{2}$, azaz a Jacobi és Gauss-Seidel iteráció +egyszerre konvergens, illetve divergens.\\ + +\noindent \textbf{Tétel}: Ha $A$ szimmetrikus, pozitív definit és tridiagonális, akkor a $J(1)$, $S(1)$ és $S(\omega)$ $\omega \in (0, 2)$- +re konvergens, és $S(\omega)$-ra az optimális paraméter értéke: + +\begin{displaymath} + \omega_{0} = \frac{2}{1 + \sqrt{1 - \varrho(B_{J})^{2}}} +\end{displaymath} + +\subsubsection{Richardson-iteráció} + +Legyen $p \in \mathbb{R}$. Így + +\begin{displaymath} + Ax = b \Longleftrightarrow + 0 = -Ax + b \Longleftrightarrow + 0 = -pAx + pb \Longleftrightarrow + x = (I-pA)x +pb +\end{displaymath} + +Az iteráció tehát $x^{(k+1)} := (I-pA)x^{(k)} +pb$. Az átmenetmátrix: $B_{R(p)} = I-pA)$. Az +$r^{(k)} := b - Ax^{(k)} $ vektort maradékvektornak (reziduumvektornak) nevezzük, hiszen + +\begin{displaymath} + x^{(k+1)} = x^{(k)} - pAx^{(k)} + pb = x^{(k)} + pr^{(k)} +\end{displaymath} + +\begin{displaymath} + r^{(k+1)} = b - Ax^{(k+1)} = b - A(x^{(k)} + pr^{(k)}) = r^{(k)} - pAr^{(k)} +\end{displaymath} + +\noindent Tekintsük az előállítás algoritmusát: $r^{(0)} := b - Ax^{(0)}$, továbbá a fentiek miatt: + +\begin{displaymath} + x^{(k+1)} := x^{(k)} + pr^{(k)} +\end{displaymath} + +\begin{displaymath} + r^{(k+1)} := r^{(k)} - pAr^{(k)} +\end{displaymath} + +\noindent \textbf{Tétel}: Ha $A$ szimmetrikus, pozitív definit, a sajátértékei pedig a következők: +\begin{displaymath} + 0 < m := \lambda_{1} \leq \lambda_{2} \leq ... \leq \lambda_{n} =: M +\end{displaymath} + +\noindent akkor $p \in (0,\frac{2}{M})$ esetén $R(p)$ konvergens, és az optimális paraméter: $p_{0} = \frac{2}{m + M}$. +Továbbá igaz, hogy: $\varrho(B_{R(p_{0})}) = \frac{M - m}{M + m}$. + +\subsection{Spline-interpoláció} + +Az eddig említett interpolációs módszerekben polinomokkal dolgoztunk. Lehetőség van arra is, hogy a megadott pontrendszerre más +típusú függvényt próbáljunk illeszteni. Igen előnyös tulajdonságokkal rendelkeznek a bizonyos folytonossági előírásoknak is +megfelelő, szakaszonként polinom függvények, a spline-ok.\\ + +\noindent \textbf{$l$-edfokú spline}: Legyen adott $\Omega_{n} = \left\{x_{0}, x_{1}, ..., x_{n}\right\}$ az $[a,b]$ intervallum egy +felosztása, ahol $x_{0}=a, x_{n}=b$ és $l \in \mathbb{N}$. Az $s:[a,b] \to \mathbb{R}$ függvény egy $l$-edfokú spline az +$\Omega_{n}$-re vonatkozóan, ha: + +\begin{enumerate} + \item $s_{|[x_{k-1},x_{k}]}$ egy $l$-edfokú polinom $\forall k = 1,..,n$ + + \item $s \in C^{l-1}[a,b]$, tehát a teljes intervallumon $(l-1)$-szer folytonosan derviálható +\end{enumerate} + +\noindent Jelölés: $s_{l}(\Omega_{n})$ az $\Omega_{n}$-hez tartozó $l$-edfokú spline-ok halmaza.\\ + +\noindent \textbf{Spline-interpoláció}: Legyenek adottak $x_{k},f(x_{k})$ értékek $k=0,1,..,n$-re és $l \in \mathbb{N}$. +Keressük azt az $s \in s_{l}(\Omega_{n})$ spline-t, amelyre $s(x_{k}) = f(x_{k})$. Ehhez elő kell állítanunk minden +intervallumra egy $l$-edfokú polinomot. Ha a polinomokat az együtthatóikkal reprezentáljuk, akkor ez $n(l+1)$ ismeretlen. +Az előírt feltételek száma: $2n$ interpolációs és $(l-1)(n-1)$ folytonossági feltétel, hiszen csak a belső pontokban kell +előírni az illető deriváltakra vonatkozó megfelelő folytonossági feltételt. Az így kapott összes feltétel darabszáma +$(l+1)n - (l-1)$, tehát az egyértelműséghez $l-1$ feltétel hiányzik még. Ezeket úgynevezett peremfeltételekkel adjuk meg. +Pl. a harmadfokú spline-interpolációhoz 2 peremfeltétel szükséges. Ezek a következők (ezek közül elég egyet választani, +mert mindegyik 2 feltételt tartalmaz): + +\begin{enumerate} + \item Természetes peremfeltétel: $s''(a) = s''(b) = 0$. + + \item Hermite-féle peremfeltétel: $s'(a) = s_{a}, s'(b) = s_{b}$, ahol $s_{a}, s_{b}$ előre megadott számok. + + \item Periodikus peremfeltétel (ekkor feltételezzük, hogy $s(a) = s(b)$ is teljesül): + $s'(a) = s'(b)$ és $s''(a) = s''(b)$ +\end{enumerate} + +\noindent \textbf{Elsőfokú spline előállítása}: Az elsőfokú spline előállítása triviális szakaszonkénti +lineáris Lagrange-interpolációval.\\ + +\noindent \textbf{Másodfokú spline előállítása}: Egyetlen peremfeltétel szükséges, legyen a következő: $s'(a) = s_{a}$ +valamilyen $s_{a}$ számra. Az $[x_{0},x_{1}]$ szakaszon Hermite-interpolációval előállítjuk azt a $H_{2}$ másodfokú +polinomot, amely megfelel az interpolációs feltételeknek és a peremfeltételnek. Az így kapott polinom $x_{1}$-beli +deriváltja meghatározott, tehát a folytonos deriválhatóság miatt az $[x_{1},x_{2}]$ szakaszon a bal végpontban +adott a derivált értéke. Ismét Hermite-interpolációt alkalmazva megkapjuk az $[x_{1},x_{2}]$ szakaszhoz tartozó +polinomot. Ezt az eljárást ismételve állíthatjuk elő a másodfokú interpolációs spline-t.\\ + +\noindent \textbf{Függvény tartója}: A $supp(f) := \overline{\left\{x \in \mathbb{R}: f(x) \not = 0 \right\}}$ halmazt +az $f$ függvény tartójának nevezzük.\\ + +\noindent \textbf{Számegyenes felosztása}: $\Omega_{\infty} := \left\{...,x_{-2},x_{-1},x_{0},x_{1},...x_{n},x_{n+1},...\right\}$\\ + +\noindent \textbf{B-spline}: A $B_{l,k}, k \in \mathbb{Z}$ $l$-edfokú spline függvények rendszerét B-spline függvényeknek +nevezzük, ha az alábbi feltételek teljesülnek: +\begin{enumerate} + \item $supp(B_{l,k}) = [x_{k},x_{k+l+1}]$, azaz a tartója minimális + + \item $B_{l,k}(x) \geq 0$ + + \item $\displaystyle\sum_{k \in \mathbb{Z}}B_{l,k}(x) = 1$ +\end{enumerate} + +\end{document} \ No newline at end of file diff --git a/3. Numerikus módszerek/Numerikus_Integralas.pdf b/3. Numerikus módszerek/Numerikus_Integralas.pdf new file mode 100644 index 0000000..2af0070 Binary files /dev/null and b/3. Numerikus módszerek/Numerikus_Integralas.pdf differ diff --git a/3.Numerikus módszerek/img/newton_pelda.png b/3. Numerikus módszerek/img/newton_pelda.png similarity index 100% rename from 3.Numerikus módszerek/img/newton_pelda.png rename to 3. Numerikus módszerek/img/newton_pelda.png diff --git a/4. Számelmélet, gráfok, (Kódoláselmélet)/4. Számelmélet, gráfok.pdf b/4. Számelmélet, gráfok, (Kódoláselmélet)/4. Számelmélet, gráfok.pdf new file mode 100644 index 0000000..68b01a5 Binary files /dev/null and b/4. Számelmélet, gráfok, (Kódoláselmélet)/4. Számelmélet, gráfok.pdf differ diff --git a/4. Számelmélet, gráfok, (Kódoláselmélet)/4. Számelmélet, gráfok.tex b/4. Számelmélet, gráfok, (Kódoláselmélet)/4. Számelmélet, gráfok.tex new file mode 100644 index 0000000..9b6b51c --- /dev/null +++ b/4. Számelmélet, gráfok, (Kódoláselmélet)/4. Számelmélet, gráfok.tex @@ -0,0 +1,779 @@ +\documentclass[margin=0px]{article} + +\usepackage{listings} +\usepackage[utf8]{inputenc} +\usepackage{graphicx} +\usepackage{float} +\usepackage[a4paper, margin=0.7in]{geometry} +\usepackage{subcaption} +\usepackage{amsthm} +\usepackage{amssymb} +\usepackage{amsmath} +\usepackage{fancyhdr} +\usepackage{setspace} + +\onehalfspacing + +\renewcommand{\figurename}{ábra} +\newenvironment{tetel}[1]{\paragraph{#1 \\}}{} + +\newcommand{\N}{\mathbb{N}} +\newcommand{\Z}{\mathbb{Z}} +\newcommand{\R}{\mathbb{R}} +\newcommand{\Q}{\mathbb{Q}} +\newcommand{\C}{\mathbb{C}} + +\pagestyle{fancy} +\lhead{\it{PTI BSc Záróvizsga tételek}} +\rhead{4. Számelmélet, gráfok} + +\title{\textbf{{\Large ELTE IK - Programtervező Informatikus BSc} \vspace{0.2cm} \\ {\huge Záróvizsga tételek}} \vspace{0.3cm} \\ 4. Számelmélet, gráfok} +\author{} +\date{} + +\begin{document} +\maketitle + +\begin{tetel}{Számelmélet, gráfok, kódoláselmélet} + Halmazok, relációk, függvények és műveletek. Komplex számok. Leszámlálások véges halmazokon. Irányítatlan és irányított gráfok, fák, Euler-és Hamilton-gráfok, gráfok adatszerkezetei. Számelméleti alapfogalmak, oszthatóság, kongruencia, prímek. Polinomok és műveleteik, maradékos osztás. +\end{tetel} +\section{Számelmélet} +\subsection{Halmazok} +A halmaz (rendszer, osztály, összesség, ...) elemeinek gondolati burka. Egy halmazt az elemei egyértelműen meghatároznak. +\begin{description} + \item[Alapfogalmak] \hfill + \begin{itemize} + \item Üres halmaz \\ + Az a halmaz, amelynek nincs eleme az Üres halmaz. Jele: $\emptyset$ . A meghatározottsági axióma alapján ez egyértelmű + \item Részhalmaz \\ + $(x,y)$ rendezett pár, ha $(x,y) = (u,v) \Longleftrightarrow x = u \ \land \ y = v$. Ezt a tulajdonságot halmazokkal definiáljuk: + \[ (x,y) := \{ \{x\}, \{x, y\} \} \] + \item Hatvány halmaz \\ + Ha {\it A} egy halmaz, akkor azt a halmazrendszert, melynek elemei pontosan az {\it A} halmaz részhalmazai az {\it A} hatványhalmazának mondjuk, és $2^A$-val jelöljük. + \begin{itemize} + \item $A = \emptyset , 2^\emptyset = {\emptyset}$ + \item $A = \{a\} , 2^{\{a\}} = \{\emptyset, \{a\}\}$ + \item $A = \{a, b\} , 2^{\{a,b\}} = \{\emptyset, \{a\}, \{b\}, \{a, b\}\}$ + \item $|2^A| = 2^{|A|}$ + \end{itemize} + \end{itemize} + \item[Műveletek] \hfill + \begin{itemize} + \item Unió \\ + Az {\it A} és {\it B} halmazok uniója: $A \cup B$ az a halmaz, mely pontosan az {\it A} és a {\it B} elemeit tartalmazza. + \item Metszet \\ + Az {\it A} és {\it B} halmazok metszete: $A \cap B$ az a halmaz, mely pontosan az {\it A} és a {\it B} közös elemeit tartalmazza: $A \cap B = \{ x \in A : x \in B \}$ + \item Diszjunkt \\ + Ha $A \cap B = \emptyset$, akkor {\it A} és {\it B} diszjunktak. + \item Különbség \\ + Az {\it A} és {\it B} halmazok különbsége az $A \diagdown B = \{ x \in A : x \notin B \}$ + \item Komplementer \\ + Egy rögzített {\it X} alaphalmaz és $A \subseteq X$ részhalmaz esetén az {\it A} halmaz komplementere az $ \overline{A} = A' = X \diagdown A$ + \item Szimmetrikus differencia \\ + $A \triangle B = (A \diagdown B) \cup (B \diagdown A)$ + \end{itemize} + \item[Tulajdonságok] \hfill + \begin{itemize} + \item Unió + \begin{itemize} + \item $A \cup \emptyset = A$ + \item $A \cup ( B \cup C ) = (A \cup B) \cup C$ (asszociativitás) + \item $A \cup B = B \cup A$ (kommutativitás) + \item $A \cup A = A$ (idempotencia) + \item $A \subseteq B \Longleftrightarrow A \cup B = B$ + \end{itemize} + \item Metszet + \begin{itemize} + \item $A \cap \emptyset = \emptyset$ + \item $A \cap ( B \cap C ) = (A \cap B) \cap C$ (asszociativitás) + \item $A \cap B = B \cap A$ (kommutativitás) + \item $A \cap A = A$ (idempotencia) + \item $A \subseteq B \Longleftrightarrow A \cap B = A$ + \end{itemize} + \item Unió és Metszet disztributivitási tulajdonságai + \begin{itemize} + \item $A \cap ( B \cup C ) = (A \cap B) \cup (A \cap C)$ + \item $A \cup ( B \cap C ) = (A \cup B) \cap (A \cup C)$ + \end{itemize} + \item Különbség + \begin{itemize} + \item $A \diagdown B = A \cap \overline{B}$ + \end{itemize} + \item Komplementer + \begin{itemize} + \item $\overline{\overline{B}} = A$ + \item $\overline{\emptyset} = X$ + \item $\overline{X} = \emptyset$ + \item $A \cap \overline{A} = \emptyset$ + \item $A \cup \overline{A} = X$ + \item $A \subseteq B \Longleftrightarrow \overline{B} \subseteq \overline{A}$ + \item $\overline{A \cap B} = \overline{A} \cup \overline{B}$ + \item $\overline{A \cup B} = \overline{A} \cap \overline{B}$ + \end{itemize} + \item Szimmetrikus differencia + \begin{itemize} + \item $A \triangle B = (A \cup B) \diagdown (B \cap A)$ + \end{itemize} + \end{itemize} +\end{description} + +\subsection{Relációk, rendezések} +\begin{description} + \item[Alapfogalmak] \hfill + \begin{itemize} + \item Rendezett pár \\ + $(x,y)$ rendezett pár, ha $(x,y) = (u,v) \Longleftrightarrow x = u \ \land \ y = v$. Ezt a tulajdonságot halmazokkal definiáljuk: + \[ (x,y) := \{ \{x\}, \{x, y\} \} \] + \item Descartes-szorzat \\ + $X,Y$ halmazok Descartes-szorzata vagy direkt szorzata: + \[ X \times Y := \{ (x,y) : x \in X, y \in Y \} \] + \item Binér reláció \\ + Egy halmazt binér relációnak nevezünk, ha minden eleme rendezett pár. + Ha $R$ binér reláció és $(x,y) \in R$, akkor gyakran írjuk: $xRy$ + \item Reláció \\ + Ha $X,Y$ halmazokra $R \subset X\times Y$, akkor $R$ reláció $X$ és $Y$ között. + \item Értelmezési tartomány \\ + Az $R$ binér reláció értelmezési tartománya: + \[ \textrm{dmn}(R) := \{ x\ | \ \exists y : (x,y)\in R \}\] + \item Érték készlet \\ + Az $R$ binér reláció érték készlete: + \[ \textrm{rng}(R) := \{ y\ | \ \exists x : (x,y)\in R \}\] + \item Inverz \\ + Egy $R$ binér reláció inverze: + \[R^{-1} := \{(a,b) : (b,a) \in R\} \] + \item Halmaz képe \\ + Legyen $R$ binér reláció, és $A$ halmaz. Az $A$ halmaz képe: + \[R(A) := \{y \ | \ \exists x\in A: (x,y) \in R\} \] + \item Kompozíció \\ + $R$ és $S$ binér relációk kompozíciója: + \[ R \circ S := \{ (x,y) \ | \ \exists z : (x,z) \in S \ \land \ (z,y) \in R \ \} \] + \end{itemize} + \item[Tulajdonságok] \hfill \\ + Az $R$ egy $X$-beli binér reláció (azaz $R \subset X\times X$) + \begin{enumerate} + \item tranzitív \\ + \[\forall x,y,z : (x,y)\in R \ \land \ (y,z) \in R \Longrightarrow (x,z) \in R \] + \item szimmetrikus \\ + \[\forall x,y : (x,y)\in R \Longrightarrow (y,x) \in R \] + \item antiszimmetrikus \\ + \[\forall x,y : (x,y)\in R \ \land \ (y,x) \in R \Longrightarrow x = y\] + \item szigorúan antiszimmetrikus \\ + \[\forall x,y : (x,y)\in R \Longrightarrow (y,x) \notin R\] + \item reflexív \\ + \[\forall x \in X : (x,x)\in R\] + \item irreflexív \\ + \[\forall x \in X : (x,x)\notin R\] + \item trichotóm \\ + Ha minden $x,y \in X$ esetén az alábbiak közül pontosan egy teljesül + \begin{enumerate} + \item[a)] $x=y$ + \item[b)] $(x,y) \in R$ + \item[c)] $(y,x) \in R$ + \end{enumerate} + \item dichotóm \\ + \[\forall x,y \in X : (x,y) \in R \ \lor \ (y,x) \in R\] + Más néven az elemek összehasonlíthatóak. + \end{enumerate} + \item[Rendezések] \hfill + \begin{itemize} + \item Ekvivalenciareláció, osztályozás \\ + $X$ halmaz, $R$ $X$-beli binér reláció ekvivalenciareláció, ha + \begin{itemize} + \item Reflexív + \item Tranzitív + \item Szimmetrikus + \end{itemize} + + $X$ részhalmazainak egy $\mathcal{O}$ rendszerét osztályozásnak hívjuk, ha $\mathcal{O}$ páronként diszjunkt nemüres halmazokból álló halmazrendszer, melyre $\cup\mathcal{O} = X$ + \\\\ + Tétel: \\ + Egy ekvivalenciareláció meghatároz egy osztályozást. Fordítva: $\mathcal{O}$ osztályozásra \\ ${R = \cup\{Y\times Y : Y \in \mathcal{O} \}}$ ekvivalenciareláció. + + \item Részbenrendezés\\ + $X$ halmaz, $R$ $X$-beli binér reláció részbenrendezés, ha + \begin{itemize} + \item Reflexív + \item Tranzitív + \item Antiszimmetrikus + \end{itemize} + \item Teljes rendezés \\ + $X$ halmaz, $R$ $X$-beli binér reláció (teljes) rendezés, ha + \begin{itemize} + \item Reflexív + \item Tranzitív + \item Antiszimmetrikus + \item Dichotóm + \end{itemize} + Magyarul ha egy részbenrendezés dichotóm (tehát minden eleme összehasonlítható), akkor (teljes) rendezés. + \item Szigorú és gyenge reláció, rendezés \\ + $X$ halmaz, $R$,$S$ relációk $X$-beliek. Ha + \[ xRy \ \land \ x \neq y \Rightarrow xSy\] + akkor $S$-et az $R$ szigorításának nevezzük.\\ + Megfordítva, ha + \[ xRy \ \lor \ x = y \Rightarrow xTy \] + akkor $T$ az $R$-hez megfelelő gyenge reláció.\\ + + \textit{Megjegyzés: Tulajdonképpen a reflexívitás elvételéről és hozzáadásáról van szó. Egy részbenrendezés esetén a megfelelő szigorú reláció (szigorú részbenrendezés) tehát irreflexív, következésképpen szigorúan antiszimmetrikus is. Megfordítva: Egy X-beli szigorú részbenrendezés (tran., irrefl., szig. ant.) megfelelő gyenge relációja részbenrendezés. } + \end{itemize} + \item[Korlátok] \hfill + \begin{itemize} + \item Legkisebb, legnagyobb, minimális, maximális elem \\ + $X$ halmazbeli részbenrendezés ($\preccurlyeq$) legkisebb (legelső) elemén egy olyan $x\in X$ elemet értünk, melyre: $\forall y \in X : x\preccurlyeq y$. (Ilyen nem biztos, hogy létezik, de ha igen, akkor egyértelmű).\\ + Hasonlóan a legnagyobb (utolsó) elem olyan $x\in X$, hogy $\forall y \in X : y \preccurlyeq x$.\\ + + $x$-et minimálisnak nevezzük, ha nincs nála kisebb elem, maximálisnak, ha nincs nála nagyobb elem. (Szemben a legkisebb/legnagyobb elemekkel, minimális/maximális elemből több is lehet. Ha viszont $X$ rendezett, akkor legkisebb=minimális, legnagyobb=maximális.) + \item Alsó, felső korlát \\ + $X$ részbenrendezett halmaz, $Y \subset X$. Az $x \in X$ elem az $Y$ alsó korlátja $\forall y \in Y : x \preccurlyeq y$. (felső korlátja: $\forall y \in Y : y \preccurlyeq x$). Látható, hogy $x$ nem feltétlenül eleme $Y$-nak, sőt az is lehet, hogy $Y$-nak nincs alsó/felső korlátja, vagy akár több is van. Ha azonban $x\in Y$, akkor egyértelmű és ez Y legkisebb eleme. + \item Infimum, szuprémum \\ + Ha az alsó korlátok között van legnagyobb elem, azt $Y$ alsó határának, infimumának nevezzük. (Jele: inf$Y$) \\ + Ha a felső korlátok között van legnagyobb elem, azt $Y$ felső határának, szuprémumának nevezzük. (Jele: sup$Y$) + \item Alsó, felső határ tulajdonság \\ + $X$ részbenrendezett halmaz. Ha $ \forall \emptyset \neq Y \subset X$ : $Y$ felülről korlátos és van szuprémuma, akkor felső határ tulajdonságú. + Illetve ha $ \forall \emptyset \neq Y \subset X$ : $Y$ alulról korlátos és van infimuma, akkor alsó határ tulajdonságú. + \end{itemize} +\end{description} +\subsection{Függvények és műveletek} +\subsubsection{Függvények} +\begin{description} + \item[Definíció] \hfill \\ + Egy $f$ reláció függvény, ha + \[ (x,y) \in f \ \land (x,y') \ \in f \Longrightarrow y = y' \] + Más szóval minden $x$-hez legfeljebb egy olyan $y$ létezik, hogy $(x,y) \in f$ + + Így minden $x \in$ dmn($f$)-re az $f(x) = \{y\}$, melyet $f(x) = y$ vagy $f: x \mapsto y$ vagy $f_x = y$ is szoktunk jelölni. + + \item[Értelmezési tartomány, értékkészlet] \hfill \\ + Az $f : X \rightarrow Y$ jelölést használjuk, ha dmn($f$) $ = X $. \\ + Az $f \in X \rightarrow Y$ jelölést használjuk, ha dmn($f$) $\subset X$ (amikor dmn($f$)$ \subsetneq X$ is előfordulhat).\\ + Mindkét esetben rng($f$) $\subset Y$. + + \item[Injektív] \hfill \\ + $f$ függvény kölcsönösen egyértelmű/injektív, ha + \[ f(x) = y \ \land \ f(x') = y \ \Longrightarrow \ x = x' \] + Ez azzal ekvivalens, hogy $f^{-1}$ reláció is függvény. + \item[Szürjektív] \hfill \\ + Az $f$ függvény szürjektív, ha + \[ \forall y \in Y : \exists x\in X : f(x) = y\] + Azaz rng($f$) = $Y$. Magyarul az $f$ függvény az egész $Y$-ra képez. + \item[Bijektív] \hfill \\ + Ha az $f$ függvény injektív és szürjektív, akkor bijektív. + \item[Indexelt család] \hfill \\ + Az $x$ függvény $i$ helyen felvett értékét $x_i$-vel is szoktuk jelölni. Ilyenkor gyakran dmn($f$) = $I$ értelmezési tartományt indexhalmaznak, elemeit indexeknek, rng($f$)-et indexelt halmaznak, és magát az $x$ függvényt indexelt családnak szoktuk nevezni. +\end{description} +\subsubsection{Műveletek} +\begin{description} + \item[Definíciók] \hfill + \begin{itemize} + \item Binér művelet \\ + $X$ halmazon egy $f : X \times X \rightarrow X$ függvény binér művelet. + \item Unér művelet \\ + $X$ halmazon egy $f : X \rightarrow X$ függvény unér művelet. + \item Nullér művelet \\ + $X$ halmaz, $f : \{\emptyset \} \rightarrow X $ nullér művelet. (Gyakorlatilag elemkiválasztás) + \end{itemize} + \item[Tulajdonságok] \hfill + \begin{itemize} + \item Legyen $\spadesuit, \copyright$ binér műveletek $X$-en. + \begin{enumerate} + \item $\spadesuit$ asszociatív, ha + \[ \forall x,y,z \in X : \quad (x \ \spadesuit \ y ) \ \spadesuit \ z = x \ \spadesuit \ (y \ \spadesuit z) \] + + \item $\spadesuit$ kommutatív, ha + \[ \forall x,y \in X : \quad x \ \spadesuit \ y = y \ \spadesuit \ x \] + + \item $\spadesuit$ disztributív a $\copyright$-ra, ha $\forall x,y,z \in X$: + \[ x \ \spadesuit \ (y \ \copyright \ z) = (x \ \spadesuit \ y) \ \copyright \ (x \ \spadesuit \ z) \quad \textrm{ - baloldali} \] + \[ (y \ \copyright \ z) \ \spadesuit \ x = (y \ \spadesuit \ x) \ \copyright \ (z \ \spadesuit \ x) \quad \textrm{ - jobboldali} \] + \end{enumerate} + + \item Legyen $\heartsuit$ binér művelet $X$-en és $\S$ binér művelet $Y$-on + $f : X \rightarrow Y$ művelettartó ha: + \[ \forall x_1,x_2 \in X: f(x_1 \heartsuit x_2) = f(x_1) \ \S \ f(x_2) \] + \end{itemize} +\end{description} +\subsection{Számfogalom, komplex számok} +\subsubsection{Számfogalom} +\begin{description} + \item[Algebrai Struktúrák] \hfill + \begin{enumerate} + \item Grupoid \\ + $G$ halmaz egy $\star$ művelettel, azaz a $(G, \star)$ párt grupoidnak nevezzük. + \item Félcsoport\\ + Ha egy grupoidban a $\star$ művelet asszociatív, akkor a grupoid félcsoport. + \item Monoid \\ + Semleges elemes félcsoportot monoidnak nevezzük.\\ + \textit{Megyjegyzés: $ a \in G$ semeleges elem, ha $\forall g \in G : a \star g = g \star a = g$} + \item Csoport \\ + Ha egy monoidban minden elemnek van inverze, akkor csoportról beszélünk. \\ + \textit{Megyjegyzés: $g,g^{-1} \in G$ és $\xi\in G$ semleges elem, akkor a $g^{-1}$ a $g$ inverze, ha $g\star g^{-1} = \xi$ és $g^{-1} \star g = \xi$} + \item Ábel-csoport \\ + Ha egy csoportban a művelet kommutatív, akkor Abel-csoport. + \item Gyűrű \\ + $(R,+,\cdot )$ gyűrű, ha az összeadással Abel-csoport, a szorzással félcsoport és teljesül mindkét oldali disztributivitás. + + Ha a szorzás kommutatív, akkor kommutatív gyűrű. + + Ha a szorzásnak van egységeleme, akkor egységelemes gyűrű. + \item Integritási tartomány \\ + Nullosztó mentes kommutatív gyűrű. + + \textit{Nullosztó: $x,y$ nullátók különböző elemek, de $x\cdot y = 0$} + \item Rendezett integritási tartomány \\ + $R$ integritási tartomány rendezett integritási tartomány, ha rendezett halmaz, továbbá az összeadás és szorzás monoton. + + \textit{Összeadás monoton: $x,y,z \in R$ és $x \leq y \ \Rightarrow \ x+z \leq y+z$ \\ + Szorzás monoton: $x,y \in R$ és $x,y\geq0 \ \Rightarrow \ x\cdot y \geq 0$ } + \item Test \\ + Egy $R$ gyűrűt, ha $R\setminus\{0\}$ szorzással Abel-csoport, akkor test. + \item Rendezett test \\ + Ha egy test rendezett integritási tartomány, akkor rendezett test. + \end{enumerate} + \item[Természetes számok]\hfill + \begin{itemize} + \item Peano-axiómák \\ + Legyen $\N$ egy halmaz és a $^+$ egy $\N$-en értelmezett függvény. Az alábbi feltételeket Peano-axiómáknak nevezzük: + \begin{enumerate} + \item $0 \in \N \qquad$ - $0$ egy nullér művelet $\N$-en + \item ha $n \in \N$, akkor $n^+ \in N \qquad$ - $^+$ egy unér művelet $\N$-en + \item ha $n \in \N$, akkor $n^+ \neq 0 \qquad $ - $0$ nincs a $^+$ értékkészletében + \item ha $n,m \in \N$, és $m^+ = n^+$, akkor $n = m \qquad $ - $^+$ injektív + \item ha $S \subset \N, 0 \in S$, továbbá $ n \in S : n^+\in S$, akkor $S = \N \qquad $ - a matematikai indukció elve + \end{enumerate} + \item Műveletek + \begin{itemize} + \item összeadás \\ + $k,m,n \in \N$, akkor: + \begin{enumerate} + \item $(k+m)+n = k+(m+n)$ \textit{- asszociativitás} + \item $n+0 = 0+n = n$ \textit{- 0 a nullelem (additív semleges elem)} + \item $n+k = k+n$ \textit{- kommutativitás} + \item $n+k = m+k$ vagy $k+n = k+m$, akkor $m=n$ \textit{- egyszerűsítési szabály} + \end{enumerate} + \item szorzás \\ + $k,m,n \in \N$, akkor: + \begin{enumerate} + \item $(k\cdot m)\cdot n = k\cdot (m\cdot n)$ \textit{- asszociativitás} + \item $ 0\cdot n = n\cdot 0 = 0$ + \item $n\cdot 1 = 1\cdot n = n$ \textit{- 1 az egységelem (multiplikatív semleges elem)} + \item $n\cdot k = k\cdot n$ \textit{- kommutativitás} + \item $k\cdot (m+n) = k\cdot m + \cdot n$, illetve $(m+n) \cdot k = m\cdot k+n\cdot k$ \textit{- disztributivitás} + \item $k\neq 0$ esetén: $n\cdot k = m\cdot k$, akkor $m=n$ \textit{- egyszerűsítési szabály} + \end{enumerate} + \end{itemize} + \end{itemize} + \item[Egész számok] \hfill \\ + Természetes számok körében az összeadásra nézve csak a nullának van inverze, másként szólva, a kivonás általában nem végezhető el. + + Tekintsük a $\sim\ \subset\N\times\N$ relációt, melyre $(m,n) \sim (m',n')$, ha $m+n' = m'+n$. És vegyük az $(m,n)+(m',n') = (m+m',n+n')$ összeadást. A $\sim$ reláció ekvivalenciareláció, az ekvivalenciaosztályok halmazát jelöljük $\Z$-vel. $\Z$ elemeit egész számoknak nevezzük. + + Az összeadás kompatibilis az ekvivalenciával, így az egész számok között értelmezve van, és $(\Z, +)$ Ábel-csoport. + + Tehát $(\Z, +, \cdot)$ gyűrű. + + \textit{Megjegyzés: $*$ művelet kompatibilis a $\asymp$ ekvivalenciarelációval, ha teljesül: $ x \asymp x' \ \land \ y \asymp y' \ \Longrightarrow \ x * y \asymp x'*y'$} + \item[Racionális számok] \hfill \\ + Az egész számok körében a nem nulla elemek közül csak az 1-nek és a $-1$-nek van multiplikatív inverze, másként szólva az osztás általában nem végezhető el. + + Tekintsük a $\Z \times (\Z\setminus\{0\})$-n a $\sim$ relációt, melyre $(m,n) \sim (m',n')$, ha $mn' = nm'$. És vegyük az $(m,n)+(m',n') = (mn'+nm', nn')$ összeadást és az $(m,n)\cdot(m',n')=(mm', nn')$ szorzást. A $\sim$ reláció ekvivalenciareláció, az ekvivalenciaosztályok halmazát jelöljük $\Q$-val. $\Q$ elemeit racionális számoknak nevezzük. + + $(\Q, +, \cdot)$ rendezett test. + \item[Valós számok] \hfill \\ + Nincs olyan $a \in \Q$ szám, melynek négyzete 2. Tehát nem minden szám írható fel m/n ($m,n \in \N^+$) alakban. + + Archimédeszi rendezettség:\\ + Egy $F$ rendezett testet archimédeszien rendezett, ha $x,y\in F: \exists n \in \N : nx \geq y \quad (x>0)$ + + A racionális számok rendezett teste archimédeszien rendezett, de nem felső határ tulajdonságú. + + Egy felső határ tulajdonságú rendezett testet a valós számok testének nevezünk, és $\R$-rel jelöljük. ($\exists!\R$) +\end{description} +\subsubsection{Komplex számok} +A komplex számok szükségét a harmadfokú egyenletek megoldására való Cardano-képlet szülte. Ugyanis abban az esetben, amikor az egyenletnek három különböző valós gyöke van, a képletben a gyökjel alá negatív szám kerül. Fokozatosan tisztult a "képzetes" számokkal való számolás szabályai, és a trigonometrikus függvényekkel való kapcsolat. + +\begin{description} + \item[Definíció] \hfill \\ + A komplex számok halmaza $\C = \R \times \R$. $\C$ az $(x,y)+(x',y') = (x+x', y+y')$ összeadással és az $(x,y)\cdot(x',y') = (xx'-yy', y'x+yx')$ szorzással test. A komplex számok halmaza nem rendezett test, mivel (tétel alapján) egy rendezett integritási tartományban $ x \neq 0 \ \Rightarrow x^2 > 0$. (Ez azonban $(0,1)^2=i^2 = -1$-re nem teljesül). + + [A komplex számok körében (0,0) a nullelem, $(1,0)$ egységelem, $(x,y)$ additív inverze $(-x,-y)$, és $(0,0) \neq (x,y)$ pár multiplikatív inverze az $(\frac{x}{x^2+y^2}, \frac{-y}{x^2+y^2})$ pár.] + \item[Valós számok azonosítása] \hfill \\ + Mivel $(x,0)+(x',0) = (x+x',0)$ és $(x,0)\cdot(x',0) = (xx',0)$ így az összes $(x,0), x\in\R$ komplex számot azonosíthatjuk $\R$-rel. + \item[Komplex számok algebrai alakja] \hfill \\ + Mivel + \[(x,y) = (x,0)+(y,0)\cdot i = x+yi\] + így a komplex számokat $a+bi$ algebrai alakban is írhatjuk. + + Ekkor az Re($z$) = $x$ valós számot a $z = (x,y)$ komplex szám valós részének, az Im($z$) = $y$ valós számot pedig a képzetes részének nevezzük. + \item[Konjugált] \hfill \\ + $ z = x+yi$ komplex szám konjugáltja: $\overline{z} = x-yi$ + + Tulajdonságai: + \begin{enumerate} + \item $\overline{z+w} = \overline{z}+\overline{w}$ + \item $\overline{z\cdot w} = \overline{z}\cdot\overline{w}$ + \item $\overline{\overline{z}} = z$ + \item $z + \overline{z}$ = 2Re($z$) + \item $z - \overline{z}$ = $i\cdot2$Im($z$) + \end{enumerate} + \item[Abszolút érték] \hfill \\ + A $z=(x,y)$ komplex szám abszolút értéke: $|z| = \sqrt{x^2+y^2}$ + + Tulajdonságai: + \begin{enumerate} + \item $z\cdot\overline{z} = {|z|}^2$ + \item $\frac{1}{z}= \frac{\overline{z}}{|z|^2} $ + \item $|z| = \overline{|z|}$ + \item $|z\cdot w | = |z|\cdot|w|$ + \item $|z+w| \leq |z| +|w|$ + \end{enumerate} + \item[Trigonometrikus alak] \hfill + \begin{itemize} + \item Argumentum \\ + $z \neq 0$ esetén az a $z$ argumentuma $\forall t \in\R$, melyre Re($z$) = $|z|$cos($t$), és Im($z$) = $|z|$sin($t$). Más szóval a $z$ argumentuma az origóból a $z$-be mutató vektor és a pozitív valós tengellyel bezárt szöge. + \item Trigonometrikus alak \\ + A $z$ komplex szám trigonometrikus alakja: $ z = |z|($cos($t$)+$i\cdot$sin($t$) + \item Moivre-azonosságok \\ + Legyen $z = |z|($cos($t$)+$i\cdot$sin($t$)), és $w = |w|($cos($s$)+$i\cdot$sin($s$)). Ekkor + \[z\cdot w = |z||w|(\textrm{cos}(t+s)+i\cdot \textrm{sin}(t+s))\] + \[\frac{z}{w} = \frac{|z|}{|w|}(\textrm{cos}(t-s)+i\cdot \textrm{sin}(t-s)) \quad (w \neq 0)\] + \[ z^n = |z|^n(\textrm{cos}(nt)+i\cdot \textrm{sin}(nt)) \quad (n \in \Z)\] + \item Gyökvonás \\ + Legyen $z^n = w$ ekkor: + \[ \sqrt[n]{w} = \Bigg\{z_k = \sqrt[n]{|w|}\bigg(\textrm{cos}\Big(\frac{t+2k\pi}{n}\Big)+\textrm{sin}\Big(\frac{t+2k\pi}{n}\Big)\bigg), k=0,...,n-1\Bigg\} \] + De mivel ez a jelöltés összetéveszthető a valósak között (egyértelművé tett) valós gyökvonással. így ezt a jelölést nem használjuk. Vezessük be helyette a n-edik komplex egységgyök fogalmát: + \[\varepsilon_k = \textrm{cos}\bigg(\frac{2k\pi}{n}\bigg)+i\cdot\textrm{sin}\bigg(\frac{2k\pi}{n}\bigg), \quad k=0,...,n-1\] + Ezek után a $w$ gyökeit a $z$ és az n-edik komplex egységgyökök segítségével kaphatjuk meg: $z\varepsilon_0, ..., z\varepsilon_{n-1}$ + \end{itemize} + +\end{description} +\subsection{Leszámlálások véges halmazokon} +\begin{description} + \item[Véges halmazok] \hfill + \begin{itemize} + \item Halmazok ekvivalenciája \\ + $X,Y$ halmazok ekvivalensek, ha létezik $X$-et $Y$-ra képező bijekció.\\ + Jele: $X \sim Y$ + \item Véges és végtelen halmazok \\ + $X$ halmaz véges, ha $\exists n\in\N : X \sim \{1,2,...,n\}$, egyébként végtelen. Ha létezik $n$, akkor az egyértelmű, és ekkor a halmaz elemszámának/számosságának nevezzük. Jele: $ \#(X)$ + \end{itemize} + \item[Skatulya elv] \hfill \\ + Ha $X,Y$ véges halmazok és $\#(X) > \#(Y)$, akkor egy $f:X\rightarrow Y$ leképezés nem lehet kölcsönösen egyértelmű (azaz bijekció). + \item[Leszámolások] \hfill + \begin{itemize} + \item Permutáció \\ + $A$ halmaz egy permutációja az önmagára való kölcsönösen egyértelmű leképezése. Az $A$ halmaz összes permutációjának száma: + \[P_n = \prod\limits_{k=1}^{n} k \ = \ n!\] + \item Variáció \\ + Az $A$ halmaz elemeiből készíthető, különböző tagokból álló $a_1,a_2,...,a_k$ sorozatokat az $A$ halmaz $k$-ad osztályú variációinak nevezzük. Ha $A$ véges ($\#(A) = n$), akkor $V_n^k$ száma megegyezik az $\{1,2,...,k\}$-t $\{1,2,...,n\}$-be képező kölcsönösen egyértelmű leképezések számával: + \[ V_n^k = \frac{n!}{(n-k)!}\] + \item Kombináció \\ + Ha $A$ halmaz $k\in\N$ elemű részhalmazait $k$-ad osztályú kombinációinak nevezzük. Ha $A$ véges, akkor $C_n^k$ száma megegyezik $\{1,2,...,n\}$ $k$ elemű részhalmazainak számával. + \[C_n^k = \dbinom{n}{k} = \frac{n!}{k!(n-k)!}\] + \item Ismétléses permutáció \\ + $A = \{a_1,\dotsc,a_r\}$ halmaz elemeinek ismétlődései $i_1,\dotsc,i_r$. (Az elemek ismétléses permutációi olyan $i_1+\cdots+i_r = n$ tagú sorozatok, melyben az $a_j$ elem $i_j$-szer fordul elő.) + \[P_n^{i_1,\dotsc,i_r} = \frac{n!}{i_1!i_2!\cdots i_r!}\] + \item Ismétléses variáció \\ + Az $A$ véges halmaz elemeiből készíthető (nem feltétlenül különböző) $a_1,\cdots,a_k$ sorozatokat, az $A$ halmaz $k$-ad osztályú ismétléses variációinak nevezzük. + \[^iV_n^k = n^k\] + \item Ismétléses kombináció \\ + Az $A$ véges halmaz. A halmazból $k$ elemet kiválasztva, ismétléseket megengedve, de a sorrend figyelmen kívül hagyva, az $A$ halmaz $k$-ad osztályú ismétléses kombinációit kapjuk. + \[^iC_n^k = \dbinom{n+k-1}{k} \] + \end{itemize} + \item[Tételek] \hfill \\ + \begin{itemize} + \item Binomiális tétel \\ + $x,y \in R$ (kommutatív egységelemes gyűrű), $n\in\R$. Ekkor + \[(x+y)^n = \sum\limits_{k=0}^n\dbinom{n}{k}x^ky^{n-k} \] + \item Polinomiális tétel \\ + $r,n\in\N$ és $x_1, x_2, \cdots, x_r \in R$ (kommutatív egységelemes gyűrű), ekkor + \[(x_1+\cdots+x_r)^n = \sum\limits_{i_1+\cdots+i_r = n}P_n^{i_1,\cdots,i_r}x_1^{i_1}x_2^{i_2}\cdots x_r^{i_r} \qquad (i_1,\cdots,i_r \in\N)\] + \item Szita formula \\ + $X_1,\cdots,X_k \subset X$ (véges halmaz). $f$ az $X$-en értelmezett, egy Abel-csoportba képző függvény. Legyen: + \[S=\sum\limits_{x\in X}f(x)\] + \[ S_r = \sum\limits_{1\leq i_1 \leq \cdots \leq i_r \leq k}\Bigg(\sum\limits_{x \in X_{i_1} \cap \cdots \cap X_{i_r}}f(x)\Bigg) \] + és + \[S_0 = \sum\limits_{x\in X \setminus \cup_{i=1}^k Xi}f(x)\] + Ekkor + \[S_0 = S - S_1+S_2-S_3+\cdots+(-1)^kS_k \] + \end{itemize} +\end{description} +\subsection{Számelméleti alapfogalmak, maradékos osztás, lineáris kongruencia-egyenletek} +\subsubsection{Számelméleti alapfogalmak} +\begin{description} + \item[Oszthatóság egységelemes integritási tartományban] \hfill \\ + $R$ egységelemes integritási tartomány, $a,b\in R$. Ha $\exists c\in R: a = bc$, akkor $b$ osztója $a$-nak ($a$ a $b$ többszöröse). Jele: $b|a$ + + A $b = 0$-t kivéve legfeljebb egy ilyen $c$ létezik. + + Az oszthatóság tulajdonságai egységelemes integritási tartományban. + \begin{itemize} + \item Ha $b|a$ és $b'|a'$, akkor $bb'|aa'$ + \item $\forall a\in R: a|0$ (a nullának minden elem osztója) + \item $0|a \Leftrightarrow a = 0$ (a null csak saját magának osztója) + \item $\forall a\in R: 1|a$ (az egységelem minden elem osztója) + \item $b|a \Rightarrow \forall c \in R : bc|ac$ + \item $bc|ac$ és $c\neq0 \Rightarrow b|a$ + \item $b|a_i$ és $c_i \in R,\ (i = 1,\cdots,j) \ \Rightarrow \ b|\sum_{i=1}^{j}a_ic_i$ + \item az $|$ reláció reflexív és tranzitív + \end{itemize} + \item[Felbonthatatlan elem és prímelem] \hfill \\ + $0,1 \neq a \in R$ felbonthatatlan (irreducibilis), ha $a = bc$ esetén $b$ vagy $c$ egység ($b,c \in R$). + + $0,1 \neq p \in R$ prím, ha $\forall a,b \in R : p|ab$ esetén $p|a$ vagy $p|b$ + \item[Legnagyobb közös osztó, legkisebb közös többszörös, relatív prím] \hfill \\ + $R$ egységelemes integritási tartomány. $a_1,\cdots,a_n \in R$ elemeknek $b\in R$ legnagyobb közös osztója, ha $b|a_i$ és $b'|a_i$ esetén $b'|b$. Ha $b$ egység, akkor $a_1, \cdots , a_n$ relatív prímek. + + $a_1,\cdots,a_n \in R$ elemeknek legkisebb közös többszöröse $b\in R$, ha $a_i|b$ és $a_i|b'$ esetén $b|b'$. + \item[Bővített euklideszi algoritmus] \hfill \\ + Az eljárás meghatározza az $a,b \in \Z$ számok legnagyobb közös osztóját ($d\in\Z$), valamint $x,y \in\Z$ számokat úgy, hogy $d = ax+by$ + \item[A számelmélet alaptétele] \hfill \\ + Minden pozitív természetes szám (sorrendtől eltekintve) egyértelműen felbontható prímszámok szorzataként. + \item[Erathoszthenész szitája] \hfill \\ + Adott $n$-ig a prímek meghatározásához: + Írjuk fel a számokat 2-től $n$-ig. Az első szám (2) prím, összes többszöröse összetett, ezeket húzzuk ki. A fennmaradó számok közül az első (3) ugyancsak prím, stb. Az eljárás végén az $n$-nél nem nagyobb prímek maradnak. +\end{description} +\subsubsection{Maradékos osztás} +Legyen $R$ egységelemes integritási tartomány, $f,g\in R[x], g \neq 0$ és tegyük fel, hogy $g$ főegyütthatója egység $R$-ben. Ekkor +\[ \exists! q,r \in R[x] : f = g\cdot q+r \qquad (\text{deg}(r) < \text{deg}(g) )\] + +\subsubsection{Horner-séma} +A Horner-módszer egy polinom helyettesítési értékének kiszámítására alkalmas. (Ezzel együtt természetesen az is eldönthető, hogy adott $c$ érték a polinom gyöke-e vagy nem. 4-ed fok felett erre még analitikus megoldás sincs.) + +A módszer lényege, hogy az egyébként $f_nx^n+f_{n-1}x^{n-1}+\cdots+f_0$ polinom helyettesítési értékének kiszámolásához rendkívül sok szorzásra és összeadásra lenne szükség. A polinom átalakításával azonban a műveletek számát lecsökkenthetjük. A maradékos osztást alkalmazva: +\[f_nx^n+f_{n-1}x^{n-1}+\cdots+f_0 = (f_nx^{n-1}+f_{n-1}x^{n-2}+\cdots)x+f_0\] +Ezt rekurzívan folytatva a következő alakra jutunk: +\[(((f_nx+f_n-1)x+f_n-2)x+\cdots)x+f_0\] +A helyettesítési érték kiszámítását egy táblázatban könnyebben elvégezhetjük. + +\begin{center} + \begin{tabular}{|c|c|c|c|c|c|} + \hline & $f_n$ & $f_{n-1}$ & $f_{n-2}$ & $\cdots$ & $f_0$ \\ + \hline $c$ & $f_n$ & $f_nc+f_{n-1}$ & $(f_nc+f_{n-1})c+f_{n-2}$ & $\cdots$ & $f(c)$ \\ + \hline + \end{tabular} +\end{center} +A táblázat kitöltése a következőképp zajlik: +\begin{enumerate} + \item Az első sorba felírjuk a polinom együtthatóit + \item A második sor első cellájába beírjuk az argumentum értékét. + \item A főegyüttható alá beírjuk önmagát. + \item A második sor celláinak kitöltésével folytatjuk + \item \label{itm:horner_recursive} Az előző cella elemét megszorozzuk az argumentummal + \item A szorzathoz adjuk hozzá az aktuális együtthatót + \item Az összeget írjuk be az aktuális cellába + \item Folytassuk az \ref{itm:horner_recursive}. ponttal, míg el nem jutunk az utolsó celláig +\end{enumerate} + +\noindent +Az utolsó cellába a polinom helyettesítési értéke kerül. (Ha ez nulla, akkor az argumentum a polinom gyöke. ) +\subsubsection{Lineáris kongruencia egyenletek} +\begin{description} + \item[Kongruencia] \hfill \\ + Ha $a,b,m \in\Z$ és $m|(a-b)$, akkor azt mondjuk, hogy $a$ és $b$ kongruensek modulo $m$ (Jele: ${a \equiv b \mod{m}}$). + + A kongruencia ekvivalenciareláció bármely $m$-re. Ha $a\in\Z$ akkor az ekvivalenciaosztály elemei $a+km, k\in\Z$ alakúak. + \item[Maradékosztályok] \hfill \\ + Az $m\in\Z$ modulus szerinti ekvivalenciaosztályoknak nevezzük. A maradékosztályokat elemeikkel reprezentáljuk. (Az $a$ elem által reprezentált maradékosztály $\widetilde{a} \mod{m}$). + + Ha egy maradékosztály valamely eleme relatív prím a modulushoz, akkor mindegyik az és a maradékosztályt redukált maradékosztálynak nevezzük. + + Páronként inkongruens egészek egy rendszerét maradékrendszernek nevezzük. + + Ha egy maradékrendszer minden maradékosztályból tartalmaz elemet, akkor teljes maradékrendszer. + + Ha maradékrendszer pontosan a redukált maradékosztályokból tartalmaz elemet, akkor redukált maradékrendszer. + \item[Euler-féle $\varphi$ függvény] \hfill \\ + $m > 0$ egész szám. Az Euler-féle $\varphi(m)$ függvény a modulo $m$ redukált maradékosztályok számát adja meg. Ez nyilván megegyezik a $0,1,\cdots,m-1$ számok közötti, $m$-hez relatív prímek számával. + \item[Euler-Fermat tétel] \hfill \\ + $m>1$ egész, $a$ relatív prím $m$-hez, ekkor: + \[a^{\varphi(m)}\equiv 1 \mod{m}\] + \item[Fermat tétel] \hfill \\ + Legyen $p$ prím, és $a\in\Z: p\nmid a$, ekkor + \[a^{p-1}\equiv 1 \mod p \] + \item[Lineáris kongruencia megoldása] \hfill \\ + Keressük az $ax \equiv b \mod{m}$ kongruencia megoldásait ($a,b,m\in\Z$ ismert). Ez ekvivalens azzal, hogy keressünk olyan $x$-et, melyre (valamely $y$-nal) $ax+my = b$. + + Legyen $d$ = lnko($a,m$). Mivel $d$ osztója $ax+my$-nak, $b$-t is osztania kell, különben nincs megoldás. Így $\frac{a}{d}x+\frac{m}{d}y = \frac{b}{d}$. Ekkor $a'x+m'y = 1$. A bővített euklideszi algoritmus segítségével olyan $u,v$ számokat kapunk, melyekkel $a'u+m'v = 1$ (ui.: $a', m'$ relatív prímek). Az egyenletet $b'$-vel beszorozva $a'ub'+m'vb' = b' \Rightarrow x \equiv ub' \mod{m'}$ + \item[Lineáris kongruenciarendszer megoldása] \hfill \\ + Két lineáris kongruencia esetén a megoldások $x \equiv a \mod{m}$ és $x \equiv b \mod{n}$. A közös megoldáshoz $x = a + my = b+ nz \Leftrightarrow my-nz = b-a$ egyenletet kell megoldani. Akkor és csak akkor van megoldás, ha $d$ = lnko($m,n$) osztója $b-a$-nak. Ekkor a megoldás valamely $x_1$ egésszel ${ x \equiv x_1 \mod{\textrm{lkkt}(m,n)}}$ alakban írható. (Több kongruencia esetén az eljárás folytatható.) + \item[Kínai maradéktétel] \hfill \\ + $1 < m_1,\cdots,m_n \in\N$ páronként relatív prímek, és $c_1,\cdots,c_n \in\Z$. Az $x \equiv c_j \mod{m_j}$ ($j=1,\cdots,n$) kongruenciarendszer megoldható, és bármely két megoldása kongruens $\mod{m_1m_2\cdots m_n}$ +\end{description} +\section{Polinomok és műveleteik} +\begin{description} + \item[Definíció] \hfill \\ + Legyen $R$ gyűrű. Egy polinomot egy $\sum_{i=0}^{n} f_ix^i$ alakú véges összegnek tekintünk, ahol $n\in\N, f_i \in R$. + + Az $f_n$ tagot a polinom főegyütthatójának nevezzük. + \item[Műveletek] \hfill \\ + Legyen $R[x]$ az $f = (f_0, f_1, \cdots)$ végtelen sorozatok feletti gyűrű (polinomok gyűrűje), ahol $f_i \in R$. Ekkor az $R[x]$-beli műveletek: + \begin{itemize} + \item Összeadás: \\ + \[f+g = (f_0+g_0, f_1+g_1,\cdots)\qquad (f,g \in R[x]) \] + \item Szorzás: \\ + \[f\cdot g = h = (h_0,h_1, \cdots) \qquad (f,g,h \in R[x]) \text{, ahol} \] + \[h_k = \sum\limits_{i+j = k}f_ig_j\] + \end{itemize} + + \textit{Megjegyzés: Ha $R$ kommutatív, akkor $R[x]$ is az. Ha $R$ egységelemes az 1 egységelemmel, akkor $R[x]$ is az az $(1,0,0, \cdots)$ egységelemmel.} +\end{description} +\section{Gráfok} +\subsection{Általános és síkgráfok} +\begin{description} + \item[Alapfogalmak] \hfill + \begin{itemize} + \item Irányítatlan gráf\\ + Egy irányítatlan gráf a $G = (V,E, \varphi)$ rendezett 3-as, ahol:\\ + $V$ - a csúcsok halmaza \\ + $E$ - élek halmaza \\ + $\varphi$ - illeszkedési reláció ($\varphi \in E \times V$) + + \textit{Ha $v\in\varphi(e)$, akkor $v$ illeszkedik az $e$ élre. ($v\in V, e\in E$). Egy élnek mindig két vége van} + + \item Él-, és csúcstípusok + \begin{itemize} + \item Izolált csúcs \\ + $v\in V$ izolált csúcs, ha $\nexists e \in E: v\in \varphi(e)$ + \item Párhuzamos él \\ + $e,e'\in E$ élek párhuzamos élek, ha $\varphi(e) = \varphi(e')$ + \item Hurokél \\ + $e\in E$ hurokél, ha $|\varphi(e) | = 1$ + \end{itemize} + \item Irányított gráf \\ + Egy irányítatott gráf a $G = (V,E, \psi)$ rendezett 3-as, ahol:\\ + $V$ - a csúcsok halmaza \\ + $E$ - élek halmaza \\ + $\psi$ - illeszkedési reláció ($\psi \in E \rightarrow V \times V$) + + \textit{$\psi(e) = (v,v')$, ahol $v$ az $e$ él kezdőpontja, $v'$ a végpontja.} + \end{itemize} + \item[Véges, egyszerű gráfok - alapfogalmak] \hfill + \begin{itemize} + \item Egyszerű gráf \\ + $G$ gráf egyszerű, ha nem tartalmaz párhuzamos vagy hurokéleket + \item Véges gráf + $G= (V,E,\varphi)$ gráf véges, ha $V,E$ véges halmazok. + \item Szomszédság, fok\\ + Két él szomszédos, ha van közös pontjuk.\\ + Két csúcs szomszédos, ha van közös élük. \\ + $v\in V$ szomszédjainak száma a $v$ foka. [Jele: deg($v$) = d($v$)] + \item $r$-reguláris gráfok\\ + $G$ gráf $r$-reguláris, ha minden pont foka $r$ + \item Teljes gráf\\ + $G$ gráf teljes gráf, ha minden él be van húzva, más szóval $(|V|-1)$-reguláris. (Jele: $K_{|V|}$) + \item Páros gráf\\ + $G$ páros gráf, ha $V = V' \cup V''$ és $V'\cap V'' = \emptyset$ (diszjunkt), valamint él csak $V'$ és $V''$ között fut. + + \textit{Ha viszont így $V'$ és $V''$ között minden él be húzva, akkor teljes páros gráf. (Jele: $K_{n,m}$, ahol $n=|V'|, m=|V''|$)} + \item Részgráf \\ + $G = (V,E,\varphi)$ részgráfja $G'=(V',G',\varphi')$-nek, ha $V\subset V \ \land \ E \subset E' \ \land \ \varphi \subset \varphi'$ + \item Séta, vonal, út \\ + $G$ gráfban egy $n$ hosszú séta $v$-ből $v'$-be egy olyan + \[v_0,e_1,v_1,\cdots,v_{n-1},e_n,v_n\] + sorozat, melyre $v=v_1, v'=v_n$ és $v_{i-1},v_{i} \in \varphi(e_i)$ + + Egy séta vonal, ha minden él legfeljebb egyszer szerepel a sorozatban. + + Egy vonal út, ha minden csúcs legfeljebb egyszer szerepel a sorozatban. + + Egy séta/vonal/út zárt, ha kezdő és végpontja megegyezik, egyébként nyílt. + \item Összefüggő gráf + Egy gráf összefüggő, ha bármely két csúcs közt van út. + + \textit{Ez a reláció ekvivalenciareláció, melynek ekvivalenciaosztályait komponenseknek nevezzük.} + \item Címkézett, Súlyozott gráf \\ + $G=V,E,\varphi, C_e, c_e, C_v,c_v)$ rendezett 7-es címkézett gráfot jelöl, ahol $C_e, C_v$ tetszőleges halmazok, és + \[c_e:E\rightarrow C_e\] + \[c_v:E\rightarrow C_v\] + + Ha $C_e = C_v = \R^+$, akkor a gráfot súlyozott gráfnak nevezzük, és $w$ a csúcs/él súlya. (${w(e)=c_e(e)},\ {w(v) = c_v(v)}$) + \end{itemize} + \item[Síkba rajzolhatóság] \hfill + \begin{description} + \item[Fogalmak] \hfill + \begin{itemize} + \item Síkba rajzolhatóság \\ + Egy gráf síkba rajzolható, ha lerajzolható úgy, hogy az elei nem keresztezik egymást. + \item Topologikus izomorfia \\ + Két gráf topologikusan izomorf, ha a következő lépést illetve fordítottját véges sok ismétlésével egyikből a másikat kapjuk: Egy másodfokú csúcsot elhagyunk, és a szomszédjait összekötjük. + \item Tartomány \\ + Ha $G$ gráf síkba rajzolható, akkor a tartományok az élek által határolt síkidomok. (A nem korlátolt síkidom is tartomány.) + \end{itemize} + \item[Tételek] \hfill + \begin{enumerate} + \item Minden véges gráf $\R^3$-ban lerajzolható. + \item Ha egy véges gráf síkba rajzolható $\Longleftrightarrow$ gömbre rajzolható + \item Euler-tétel: \\ + Ha a $G$ véges gráf összefüggő, síkba rajzolható gráf, akkor: + \[|E|+2 = |V|+|T|\] + \item Kuratowsky-tétel: \\ + Egy véges gráf pontosan akkor síkba rajzolható, ha nem tartalmaz $K_5$-tel, vagy $K_{3,3}$-mal topologikusan izomorf részgráfot. + \end{enumerate} + \end{description} +\end{description} +\subsection{Fák} +\begin{description} + \item[Fa]\hfill \\ + Egy gráfot fának nevezünk, ha összefüggő és körmentes. + \item[Feszítőfa] \hfill \\ + $F$ részgráfja $G$-nek. Ha $F$ fa és csúcsainak halmaza megegyezik $G$ csúcsainak halmazával, akkor $F$-et a $G$ feszítőfájának nevezzük. + \item[Tételek] \hfill + \begin{itemize} + \item Ha $G$ egyszerű gráf, akkor a következő feltételek ekvivalensek: + \begin{enumerate} + \item $G$ fa + \item $G$ összefüggő, de bármely él törlésével már nem az + \item Két különböző csúcs között csak egy út van + \item $G$ körmentes, de egy él hozzáadásával már nem az + \end{enumerate} + \item Ha $G$ egyszerű véges gráf, akkor a következő feltételek ekvivalensek: + \begin{enumerate} + \item $G$ fa + \item $G$-ben nincs kör és $n-1$ éle van + \item $G$ összefüggő és $n-1$ éle van + \end{enumerate} + \end{itemize} + \item[Irányított fa] \hfill \\ + Olyan fa, melyre: $\exists v \in V : d^-(v) = 0$ és $\forall v'\neq v : d^-(v') = 1$ + (Egy csúscs befoka 0, a többié 1) + + További fogalmak: + \begin{itemize} + \item $r \in V, d^-(r) = 0 $ csúcsot gyökérnek nevezzük + \item $v'$ csúcs szintje a $r,v'$ út hossza + \item $(v,v')\in\psi(e)$, a $v$ szülője $v'$-nek, $v'$ gyereke, $v$-nek. + \item $v$ levél, ha $d^+(v)=0$ + \end{itemize} +\end{description} +\subsection{Euler- és Hamilton-gráfok} +\subsubsection{Euler-gráf} +\begin{description} + \item[Euler-vonal] \hfill \\ + Az Euler-vonal olyan vonal $v$-ből $v'$-be a gráfban, amelyben minden él szerepel. Ha $v=v'$ akkor ezt a vonalat Euler-körvonalnak is szokás nevezni. Euler-vonallal rendelkező gráfot Euler-gráfnak nevezik. + \item[Tétel] \hfill \\ + Egy összefüggő véges gráfban pontosan akkor létezik Euler-körvonal, ha minden csúcs páros fokú. +\end{description} +\subsubsection{Hamilton-gráf} +A Hamilton-út egy olyan út $v$-ből $v'$-be a gráfban, mely minden csúcsot tartalmat. Ha $v=v'$ akkor ezt az utat Hamilton-körnek is szokás nevezni. Hamilton-úttal rendelkező gráfot Hamilton-gráfnak nevezik. +\subsection{Gráfok adatszerkezetei} +Gráfok számítógépes reprezentációjához legtöbbször láncolt listákat, vagy mátrixokat szoktak használni. A láncolt listák inkább ritka gráfokra, míg a mátrixok sűrű gráfok esetén gazdaságosak. +\begin{description} + \item[Illeszkedési mátrix] \hfill \\ + $G = (V,E, \psi)$ irányított gráf esetén a gráfot egy $A = \{0,1,-1\}^{n\times m}$ mátrix segítségével tudjuk reprezentálni, ahol $V = \{v_1,\cdots, v_n\}$, és $E = \{e_1,\cdots,e_m\}$. Ekkor a mátrix egyes elemei: + \[ a_{ij} = + \left\{ + \begin{array}{ll} + 1 & \mbox{ha} \ v_i \ \text{kezdőpontja} \ e_j\text{-nek} \\ + -1 & \mbox{ha} \ v_i \ \text{végpontja} \ e_j\text{-nek} \\ + 0 & \mbox{különben} + \end{array} + \right. + \] + + Ha $G$ nem irányított, akkor $a_{ij} = |a_{i,j}|$ + \item[Csúcsmátrix] \hfill \\ + A fenti jelölésekkel irányított esetben $B \in \Z^{n\times n}$, ahol $b_{ij}$ a $v_i$-ből $v_j$-be menő élek számát jelöli. + + Ha $G$ irányítatlan, akkor $b_{ii}$ $v_i$ hurokéleinek száma, egyébként $b_{ij}$ a $v_i$ és $v_j$ csúcsok közötti élek száma. +\end{description} + +\end{document} \ No newline at end of file diff --git a/4. Számelmélet, gráfok, (Kódoláselmélet)/4.1 Kódoláselmélet.pdf b/4. Számelmélet, gráfok, (Kódoláselmélet)/4.1 Kódoláselmélet.pdf new file mode 100644 index 0000000..8ed567d Binary files /dev/null and b/4. Számelmélet, gráfok, (Kódoláselmélet)/4.1 Kódoláselmélet.pdf differ diff --git a/4. Számelmélet, gráfok, (Kódoláselmélet)/4.1 Kódoláselmélet.tex b/4. Számelmélet, gráfok, (Kódoláselmélet)/4.1 Kódoláselmélet.tex new file mode 100644 index 0000000..cb7049b --- /dev/null +++ b/4. Számelmélet, gráfok, (Kódoláselmélet)/4.1 Kódoláselmélet.tex @@ -0,0 +1,267 @@ +\documentclass[margin=0px]{article} + +\usepackage{listings} +\usepackage[utf8]{inputenc} +\usepackage{graphicx} +\usepackage{float} +\usepackage[a4paper, margin=0.7in]{geometry} +\usepackage{subcaption} +\usepackage{amsthm} +\usepackage{amssymb} +\usepackage{amsmath} +\usepackage{fancyhdr} +\usepackage{setspace} + +\onehalfspacing + +\renewcommand{\figurename}{ábra} +\newenvironment{tetel}[1]{\paragraph{#1 \\}}{} + +\newcommand{\N}{\mathbb{N}} +\newcommand{\Z}{\mathbb{Z}} +\newcommand{\R}{\mathbb{R}} +\newcommand{\Q}{\mathbb{Q}} +\newcommand{\C}{\mathbb{C}} + +\pagestyle{fancy} +\lhead{\it{PTI BSc Záróvizsga tételek}} +\rhead{4.1 Kódoláselmélet} + +\title{\textbf{{\Large ELTE IK - Programtervező Informatikus BSc} \vspace{0.2cm} \\ {\huge Záróvizsga tételek}} \vspace{0.3cm} \\ 4.1 Kódoláselmélet} +\author{} +\date{} + +\begin{document} +\maketitle + +\section{Kódoláselmélet} +\subsection{Betűnkénti kódolás} +A kódolás a legáltalánosabb értelemben az üzentek halmazának egy másik halmazba való leképzését jelenti. Gyakran az üzenetet valamilyen karakterkészlet elemeiből alkotott sorozattal adjuk meg. Ekkor az üzenetet felbontjuk előre rögzített olyan elemi részekre, hogy minden üzenet egyértelműen előálljon ilyen elemi részek sorozataként. A kódoláshoz megadjuk az elemi részek kódját, amelyet egy szótár tartalmaz. Az ilyen kódolást betűnkénti kódolásnak nevezzük. + +A kódolandó üzenetek egy $A$ ábécé betűi, és egy-egy betű kódja egy másik, $B$ ábécé (kódábécé) betűinek felel meg. Tegyük fel, hogy mind két ábécé nem üres és véges. + +Egy $A$ ábécé betűiből felírható szavak halmazát $A^+$-szal jelöljük, míg az üres szóval kiterjesztettet $A^*$-gal. + +Ez alapján a betűnkénti kódolást egy $\varphi: A \rightarrow B^*$ leképezés határozza meg, amelyet kiterjeszthetünk egy $\psi: A^* \rightarrow B^*$ leképezéssé, alábbi módon: Ha $\alpha_1\alpha_2...\alpha_n = \alpha \in A$, akkor $\alpha$ kódja $\psi(\alpha) = \varphi(\alpha_1)\varphi(\alpha_2)...\varphi(\alpha_3)$. Nyilván ha $\varphi$ nem injektív (vagy az üres szó benne van az értékkészletében), akkor a $\psi$ kódolás sem injektív, azaz nem egyértelműen dekódolható. Emiatt feltehetjük, hogy $\varphi$ injektív, és $B^+$-ba képez. + +\subsection{Shannon- és Huffman-kód} +\begin{description} + \item[Alapfogalmak] \hfill + \begin{itemize} + \item Gyakoriság, relatív gyakoriság, eloszlás \\ + Az információforrás $n$ üzenetet bocsájt ki. A különböző üzeneteket jelöljük $a_1, \cdots, a_m$-mel. $a_i$ üzenet $k_i$-szer fordul elő, melyet gyakoriságnak nevezzük. Az $a_i$ relatív gyakorisága a $p_i = k_i/n$. A $p_1,\cdots,p_m$ szám $m$-est az üzentek eloszlásának nevezzük. ($\sum_{i=1}^{m}p_i = 1$) + \item Információtartalom \\ + Az $a_i$ üzenet egyedi információtartalma $I_i = - \text{log}_rp_i$, ahol $r>1$ az információ egysége. ($r=2$ esetén az egység a bit). + \item Entrópia \\ + Az üzenetforrás által kibocsátott átlagos információtartalmat nevezzük entrópiának: + \[H_r(p_1, \cdots, p_m) = - \sum\limits_{i=1}^{m}p_i\text{log}_rp_i \] + \item Prefix, szuffix, infix \\ + Legyen $\alpha, \beta, \gamma \in A$ szavak. Ekkor az $\alpha\beta\gamma$ szónak $\alpha$ prefixe, $\beta$ infixe, $\gamma$ pedig szuffixe. + \item Kódfa \\ + A betűnkénti kódoláshoz egyértelműen adható meg egy szemléletes irányított, élcímkézett fa. Legyen $\varphi : A \rightarrow B^*$ a betűnkénti kódolás. Készítsünk el egy olyan fát, melynek a gyökere az üres szó és ha $\beta = \alpha b\quad (b\in B)$-re, akkor $\alpha$-ból húzódjon olyan él $\beta$-ba, melynek $b$ címkéje van. Ekkor minden azonos hosszú szó egy szinten lesz. Azokat a csúcsokat, melyekből minden $b\in B$ címkével vezet ki él teljes csúcsnak nevezzük, különben csonka csúcsok. + \item Prefix kód, egyenletes kód, vesszős kód \\ + A $\varphi : A \rightarrow B^+$ injektív leképezés által meghatározott $\psi : A^* \rightarrow B^*$ betűnkénti kódolás + \begin{enumerate} + \item felbontható (egyértelműen dekódolható), ha $\psi$ injektív + \item prefix kód, ha $\varphi$ értékkészlete prefixmentes. + \item egyenletes kód (fix hosszúságú), ha $\psi$ értékkészletében minden elem megegyező hosszú + \item vesszős kód, ha $\exists \vartheta \in B^+$ vessző, hogy $\vartheta$ szuffixe minden kódszónak, de sem prefixe, sem infixe semelyik kódszónak. + \end{enumerate} + \item Átlagos szóhosszúság \\ + Legyen $A = \{a_1,\cdots, a_n\}$ a kódolandó ábécé. Az $a_i$ kódjának hossza $l_i$. Ekkor $\overline{l} = \sum_{i=1}^{n}p_il_i$ a kód átlagos szóhosszúsága. + \item Optimális kód \\ + Ha egy adott elemszámú ábécével és adott eloszlással egy felbontható betűnkénti kód átlagos szóhoszúsága minimális, akkor optimális kódnak nevezzük. + \end{itemize} + \item[Shannon-kód] \hfill \\ + Shannon kód egy optimális kód ($r$ elemszámú ábécével és $p_i$ gyakoriságokkal), melyet a következő módon állítunk elő. + \begin{enumerate} + \item Rendezzük a betűket relatív gyakoriságaik alapján csökkenő sorrendbe. + \item Határozzuk meg az $l_1,\cdots,l_n$ szóhosszúságokat a következő módon: + \[r^{-l_i} \leq p_i < r^{-l_i+1} \] + \item Osszuk el az ábécé elemeit az egyes helyiértékeken. + \end{enumerate} + Példa: + + Legyen a kódábécé a ${0,1,2}$ halmaz, az kódolandó betűk és gyakoriságaik pedig a következők: + + \begin{tabular}{|c|c|c|c|c|c|c|c|c|c|} + \hline a & b & c & d & e & f & g & h & i & j \\ + \hline 0,17 & 0,02 & 0,13 & 0,02 & 0,01 & 0,31 & 0,02 & 0,17 & 0,06 & 0,09 \\ + \hline + \end{tabular} + + A relatív gyakoriságok rendezése után: + + \begin{tabular}{|c|c|c|c|c|c|c|c|c|c|} + \hline f & a & h & c & j & i & b & d & g & e \\ + \hline 0,31 & 0,17 & 0,17 & 0,13 & 0,09 & 0,06 & 0,02 & 0,02 & 0,02 & 0,01 \\ + \hline + \end{tabular} + + Határozzuk meg szóhosszúságokat. Az f, a, h és c esetében: $3^{-2} = r^{-l_i} \leq p_i < r^{-l_i+1} = 3^{-1} $ Tehát azok szóhosszúsága 2. A többi esetben is így járunk el: + + \begin{tabular}{|c|c|c|c|c|c|c|c|c|c|} + \hline f & a & h & c & j & i & b & d & g & e \\ + \hline 0,31 & 0,17 & 0,17 & 0,13 & 0,09 & 0,06 & 0,02 & 0,02 & 0,02 & 0,01 \\ + \hline 2 & 2 & 2 & 2 & 3 & 3 & 4 & 4 & 4 & 5 \\ + \hline + \end{tabular} + + Ezek alapján f kódszava a 00, a kódszava a 01, h-hoz a 02 tartozik, míg c-hez 10. A j-hez ezek után 11 tartozna, de mivel az 3 hosszú, így 110. + A kódszavak tehát a következőképp alakulnak: + + \begin{tabular}{|c|c|c|c|c|c|c|c|c|c|} + \hline f & a & h & c & j & i & b & d & g & e \\ + \hline 0,31 & 0,17 & 0,17 & 0,13 & 0,09 & 0,06 & 0,02 & 0,02 & 0,02 & 0,01 \\ + \hline 2 & 2 & 2 & 2 & 3 & 3 & 4 & 4 & 4 & 5 \\ + \hline 00 & 01 & 02 & 10 & 110 & 111 & 1120 & 1121 & 1122 & 12000 \\ + \hline + \end{tabular} + + A kódfát \ref{fig:shannon}. ábrán láthatjuk. + + \begin{figure}[H] + \centering + \includegraphics[width=0.6\textwidth]{img/shannon.png} + \caption{Shannon-kód példa kódfája} + \label{fig:shannon} + \end{figure} + + \item[Huffman-kód] \hfill \\ + A Huffman-kód is optimális kód ($r$ elemszámú ábécével és $p_i$ gyakoriságokkal), melyet a következő módon állítunk elő. + \begin{enumerate} + \item Rendezzük a betűket relatív gyakoriságaik alapján csökkenő sorrendbe. + \item Annak érdekében, hogy csak egy csonka csúcs keletkezzen + \[m \equiv n \mod{r-1}\] + kongruenciának teljesülnie kell, ahol $m$ az egyetlen csonka csúcs kifoka. Ami ekvivalens azzal, hogy $m = 2 + ((n-2) \mod{r-1})$. Tehát osszuk el $n-2$-t $r-1$-gyel, és így $m$ a maradék+2 lesz. + \item Az első lépésben a sorozat $m$ utolsó betűjét összevonjuk (új jelölést/betűt adunk neki), és ennek a relatív gyakorisága a tagok relatív gyakoriságának összege lesz. Rendezzük a sorozatot. Ezen lépés után már a betűk száma kongruens $r-1$-gyel, így a következő redukciós lépésekben mindig teljes csúcsokat tudunk készíteni. + \item \label{itm:huffman_red} Az utolsó $r$ betűt vonjunk össze, helyettesítsük egy új betűvel és relatív gyakoriság legyen a relatív gyakoriságok összege. + \item A \ref{itm:huffman_red}-beli redukciós lépést addig ismételjük míg $r$ db betű nem marad. Ekkor rendre minden betűhöz a kódábécé egy-egy betűjét rendeljük. + \item \label{itm:huffman_split} Ha redukált elemmel találkozunk szétbontjuk, majd az ő elemeihez is a kódábécé betűit rendeljük, de konkatenáljuk az előzővel. + \item A \ref{itm:huffman_split}-beli lépést addig ismételjük míg marad redukált elem. + \end{enumerate} + + Példa: + + A Shannon-kódnál látott forrást kódoljuk be ugyanúgy $\{0,1,2\}$ kódábécével. + + \begin{tabular}{|c|c|c|c|c|c|c|c|c|c|} + \hline a & b & c & d & e & f & g & h & i & j \\ + \hline 0,17 & 0,02 & 0,13 & 0,02 & 0,01 & 0,31 & 0,02 & 0,17 & 0,06 & 0,09 \\ + \hline + \end{tabular} + + Rendezzük relatív gyakoriság szerint: + + \begin{tabular}{|c|c|c|c|c|c|c|c|c|c|} + \hline f & a & h & c & j & i & b & d & g & e \\ + \hline 0,31 & 0,17 & 0,17 & 0,13 & 0,09 & 0,06 & 0,02 & 0,02 & 0,02 & 0,01 \\ + \hline + \end{tabular} + + Osszuk el $n-2$-t $r-1$-gyel: $10-2 = 4*(3-1)+0$. Így $m$ a maradék+2, azaz $m=2$. + Az utolsó $m$ betűt összevonjuk, és rendezzük a sorozatot: + + \begin{tabular}{|c|c|c|c|c|c|c|c|c|} + \hline f & a & h & c & j & i & (g,e) & b & d \\ + \hline 0,31 & 0,17 & 0,17 & 0,13 & 0,09 & 0,06 & 0,03 & 0,02 & 0,02 \\ + \hline + \end{tabular} + + Innentől kezdve minden redukciós lépésben az utolsó $r$ db azaz 3 betűt vonjuk össze: + + \begin{tabular}{|c|c|c|c|c|c|c|} + \hline f & a & h & c & j & ((g,e), b, d) & i \\ + \hline 0,31 & 0,17 & 0,17 & 0,13 & 0,09 & 0,07 & 0,06 \\ + \hline + \end{tabular} + + Ezt addig ismételjük, míg $r$ darab betű marad: + + \begin{tabular}{|c|c|c|} + \hline (a,h,c) & f & (j,((g,e),b,d),i) \\ + \hline 0,47 & 0,31 & 0,22 \\ + \hline + \end{tabular} + + A szétbontás alapján a \ref{fig:huffmann_split}. ábrán látható fát tudjuk összeállítani. + + \begin{figure}[H] + \centering + \includegraphics[width=0.6\textwidth]{img/huffmann_split.png} + \caption{Huffman-kód példa kódfája} + \label{fig:huffmann_split} + \end{figure} + + Ezek alapján a kódtábla: + + \begin{tabular}{|c|c|c|} + \hline betű & gyakoriság & kód \\ + \hline f & 0,31 & 1 \\ + \hline a & 0,17 & 00 \\ + \hline h & 0,17 & 01 \\ + \hline c & 0,13 & 02 \\ + \hline j & 0,09 & 20 \\ + \hline i & 0,06 & 22 \\ + \hline b & 0,02 & 211 \\ + \hline d & 0,02 & 212 \\ + \hline g & 0,02 & 2100 \\ + \hline e & 0,01 & 2101 \\ + \hline + \end{tabular} +\end{description} +\subsection{Hibajavító kódok, kódtávolság} +\begin{description} + \item[Hibakorlátozó kódolás] \hfill \\ + A hibakorlátozó kódokat két csoportba sorolhatjuk: hibajelző és hibajavító kódok. Mindkét esetben az üzenetekhez kódszavakat rendelünk, amik alapján az átvitel során keletkező hibákat kezelni tudjuk. Ha az üzenet könnyen ismételhető hibajelző, ha nehezen ismételhető hibajavító kódot alkalmazunk. A hibakorlátozó kódoknál mindig azonos hosszúságú kódszavakat használunk. + \item[Kódok távolsága, súlya] \hfill \\ + A kódábécé $u$ és $v$ szavának Hamming-távolsága $d(u,v)$ az azonos pozícióban levő, eltérő jegyek száma. A Hamming-távolság rendelkezik a távolság szokásos tulajdonságaival, vagyis $\forall u,v,z$: + \begin{itemize} + \item $d(u,v) \geq 0$ + \item $d(u,v) = 0 \ \Longleftrightarrow \ u = v$ + \item $d(u,v) = d(v,u)$ - szimmetria + \item $d(u,z) \leq d(u,v)+d(v,z)$ - háromszög egyenlőtlenség + \end{itemize} + A kód távolsága $d(C) = \min\limits_{u\neq v}d(u,v) \qquad (u,v \in C)$ + + Amennyiben az $A$ kódábécé Abel-csoport a $0$ nullelemmel. Ekkor egy $u$ szó Hamming-súlya ($w(u)$) a szóban szereplő nem nulla elemek száma. Ekkor a kód súlya $w(C) = \min\limits_{u\neq 0}w(u)$ + \item[Hibajavító kód] \hfill \\ + Amikor egy olyan szót kapunk, ami nem kódszó, a hozzá legkisebb Hamming-távolságú kódszóra javítjuk. + + A $K$ kód $t$-hibajavító, ha egy legfeljebb $t$ helyen megváltozott kódot helyesen javít. A $K$ kód pontosan $t$-hibajavító, ha $t$-hibajavító, de nem $t+1$-hibajavító. + + \textit{Megjegyzés: d minimális távolságú kód esetén d/2-nél kevesebb hibát biztosan egyértelműen tudunk javítani.} + \item[Hamming-korlát] \hfill \\ + Egy $q$ elemű ábécé $n$ hosszú szavaiból álló $C$ kód $t$-hibajavító. Ekkor bármely két kódszóra a tőlünk legfeljebb $t$ távolságra lévő szavak halmazai diszjunktak. + + Mivel egy kódszótól $j$ távolságra pontosan $\binom{n}{j}(q-1)^j$ szó van, így a Hamming-korlát a kódszavak számára adott $t$-nél: + \[\#(C) \cdot \sum\limits_{j=0}^{t}\binom{n}{j}(q-1)^j \leq q^n \] + + Amennyiben egyenlőség áll fent tökéletes kódról beszélünk. +\end{description} +\subsection{Lineáris kódok} +\begin{description} + \item[Definíció] \hfill \\ + $A$ véges test és $A^n$ lineáris tér. Minden $ K \leq A^n$ alteret lineáris kódnak nevezzük. Ha az altér $k$ dimenziós, a kód távolsága $d$ és $\#(A) = q$, akkor az ilyen kódot $[n,k,d]_q$ kódnak nevezzük. + + Egy lineáris kódnál feltesszük, hogy kódolandó üzenetek $K^k$ elemei, azaz a kódábécé elemeiből képzett $k$-asok. + \item[Generátormátrix] \hfill \\ + $K$ véges test feletti $[n,k,d]_q$ lineáris kódolást válasszuk egy (kölcsönösen egyértelmű) lineáris leképezésnek: + \[ G:K^k \rightarrow K^n \] + Ezt egy mátrixszal, az úgy nevezett generátormátrixszal jellemezhetjük. + \item[Polinomkódok] \hfill \\ + Egy lineáris kód esetén az üzeneteket megfeleltethetjük $\mathbb{F}_q$ ($q$ elemű véges test) feletti $k$-nál alacsonyabb fokú polinomoknak. + \[(a_0,a_1,\cdots,a_{k-1}) \rightarrow a_0+a_1x+\cdots+a_{k-1}x^{k-1} \] + + Legyen $g(x)$ rögzített $m$-edfokú polinom. A $p(x)$ polinomot (üzenet) $g(x)$-szel szorozva lineáris kódolást kapunk (mivel a $p \rightarrow pg$ kölcsönösen egyértelmű). Ekkor a kódszavak hossza $n=k+m$. Az ilyen típusú lineáris kódolást polinomkódolásnak nevezzük. + + \textit{Megjegyzés: Feltehetjük, hogy $g(x)$ főpolinom (együtthatója egység), illetve a konstans tag nem nulla (ha nulla lenne, a szorzatban kiesne a konstans tag, így a kódban a nulla indexű betű soha nem hordozna információt)} + \item[CRC - Cyclic Redundancy Check] \hfill \\ + Ha egy polinomkódban $g(x) | x^n-1$, akkor ciklikus kódról beszélünk. Ekkor, ha $a_0a_1\cdots a_{n-1}$ kódszó, akkor $a_{n-1}a_0\cdots a_{n-2}$ is az, mivel: + \[ a_{n-1}+a_0x+\cdots+a_{n-2}x^{n-1} \ = \ x\cdot(a_0+a_1x+\cdots a_{n-1}x^{n-1})-a_{n-1}(x^n-1) \] + osztható $g(x)$-szel. + + A CRC az $\mathbb{F}_2$ feletti ciklikus kódokat foglalja magába. Csak hibajelzésre alkalmas, a kódolás a következő: Vegyük $p(x)x^m = (0,0,\cdots,0,a_m,a_{m+1},\cdots,a_{n-1})$. Ezt osszuk el $g(x)$-el maradékosan. $p(x)x^m = q(x)g(x)+r(x)$. Ekkor a kódszó legyen: $p(x)x^m-r(x) = q(x)g(x)$, amely osztható $g(x)$-szel és magas fokszámokon az eredeti üzenet betűi helyezkednek el. A vett szó ellenőrzése egyszerű: Megnézzük, hogy osztható-e $g(x)$-szel, ha nem, hiba történt. +\end{description} + +\end{document} \ No newline at end of file diff --git a/4.Számelmélet, gráfok, kódoláselmélet/img/huffmann_split.png b/4. Számelmélet, gráfok, (Kódoláselmélet)/img/huffmann_split.png similarity index 100% rename from 4.Számelmélet, gráfok, kódoláselmélet/img/huffmann_split.png rename to 4. Számelmélet, gráfok, (Kódoláselmélet)/img/huffmann_split.png diff --git a/4.Számelmélet, gráfok, kódoláselmélet/img/shannon.png b/4. Számelmélet, gráfok, (Kódoláselmélet)/img/shannon.png similarity index 100% rename from 4.Számelmélet, gráfok, kódoláselmélet/img/shannon.png rename to 4. Számelmélet, gráfok, (Kódoláselmélet)/img/shannon.png diff --git a/5. Valószínűségszámítási és statisztikai alapok/5. Valószínűségszámítási és statisztikai alapok.pdf b/5. Valószínűségszámítási és statisztikai alapok/5. Valószínűségszámítási és statisztikai alapok.pdf new file mode 100644 index 0000000..3f47878 Binary files /dev/null and b/5. Valószínűségszámítási és statisztikai alapok/5. Valószínűségszámítási és statisztikai alapok.pdf differ diff --git a/5. Valószínűségszámítási és statisztikai alapok/5. Valószínűségszámítási és statisztikai alapok.tex b/5. Valószínűségszámítási és statisztikai alapok/5. Valószínűségszámítási és statisztikai alapok.tex new file mode 100644 index 0000000..b787d20 --- /dev/null +++ b/5. Valószínűségszámítási és statisztikai alapok/5. Valószínűségszámítási és statisztikai alapok.tex @@ -0,0 +1,262 @@ +\documentclass[margin=0px]{article} + +\usepackage{listings} +\usepackage[utf8]{inputenc} +\usepackage{graphicx} +\usepackage{float} +\usepackage[a4paper, margin=0.7in]{geometry} +\usepackage{amsthm} +\usepackage{amssymb} +\usepackage{fancyhdr} +\usepackage{setspace} + +\onehalfspacing + +\newenvironment{tetel}[1]{\paragraph{#1 \\}}{} + +\pagestyle{fancy} +\lhead{\it{PTI BSc Záróvizsga tételek}} +\rhead{5. Valószínűségszámítási és statisztikai alapok} + +\title{\textbf{{\Large ELTE IK - Programtervező Informatikus BSc} \vspace{0.2cm} \\ {\huge Záróvizsga tételek}} \vspace{0.3cm} \\ 5. Valószínűségszámítási és statisztikai alapok} +\author{} +\date{} + +\begin{document} +\maketitle + +\begin{tetel}{Valószínűségszámítási és statisztikai alapok} + Diszkrét és folytonos valószínűségi változók, nagy számok törvénye, centrális határeloszlás tétel. Statisztikai becslések, klasszikus statisztikai próbák. +\end{tetel} + +\section{Kolmogorov-féle valószínűségi mező} + +$(\Omega, \mathcal{A}, P)$ hármas, ahol: +\begin{itemize} + \item [$\Omega$] nem üres halmaz, eseménytér, $\omega$ elemi esemény. + \item [$\mathcal{A}$] $\Omega$ részhalmazainak egy rendszere, $\mathcal{A} \subset 2^{\Omega}, A \in \mathcal{A}$ események, $\mathcal{A}$ $\sigma$-algebra. \\ + $\sigma$-algebra: + \begin{enumerate} + \item $\Omega \in \mathcal{A}$ + \item $A \in \mathcal{A} \Rightarrow \overline{A} = \Omega \backslash A \in \mathcal{A}$ + \item $A_{1}, A_{2}... \in \mathcal{A} \Rightarrow \bigcup_{i=1}^{\infty}{A_{i}} \in \mathcal{A}$ + \end{enumerate} + \item [$P$] $: \mathcal{A} \to [0,1]$ halmazfüggvény, valószínűség, amelyre $P(\Omega) = 1, P(A) \geq 0, \forall A \in \mathcal{A}$-ra, páronként kizáró ($A_{i} \cdot A_{j} = \emptyset, i \neq j$) $A_{1}, A_{2}... \in \mathcal{A}$ eseményekre $P(\bigcup_{i=1}^{\infty}{A_{i}}) = \sum_{i=1}^{\infty}{P(A_{i})}$. +\end{itemize} + +\section{Diszkrét és folytonos valószínűségi változók} + +\begin{itemize} + \item \textit{Valószínűségi változó}: $\xi : \Omega \to \mathbb{R}$ mérhető függvény, azaz amire $\{\omega : \xi(\omega) < x\} \in \mathcal{A}, \forall x \in \mathbb{R}$, ahol $\mathcal{A}$ az eseménytér ($\Omega$) részhalmazainak egy rendszere. ($\omega \in \Omega$ elemi esemény). + \item \textit{Valószínűségi változó eloszlása/eloszlásfüggvénye}: $F_{\xi}(x) = P(\xi < x)$, $\forall x \in \mathbb{R}$. \\ + Tulajdonságai: + \begin{enumerate} + \item $0 \leq F_{\xi}(x) \leq 1$ + \item monoton növő + \item balról folytonos + \item $\lim\limits_{x \to -\infty}{F_{\xi}(x)} = 0$, $\lim\limits_{x \to \infty}{F_{\xi}(x)} = 1$ + \end{enumerate} +\end{itemize} + +\subsection{Diszkrét valószínűségi változók} + +Értékkészlete legfeljebb megszámlálhatóan végtelen, azaz $\{x_1 ... x_n ... \}$ elemekből áll. Ekkor eloszlása: $p_k := P(\xi = x_k)$. + +\begin{tabular}{|p{2.5cm}|p{4cm}|p{4cm}|c|c|} + \hline \textbf{Név} & \textbf{Értelmezés} & \textbf{Eloszlás} & \textbf{$EX$} & \textbf{$D^{2}X$} \\ + \hline indikátor \newline $Ind(p)$ & Egy $p$ valószínűségű esemény bekövetkezik-e vagy sem. & $P(X=1) = p$ \newline $P(X=0) = 1-p$ & $p$ & $p(1-p)$ \\ + \hline geometriai (Pascal) \newline $Geo(p)$ & Hányadikra következik be először egy $p$ valószínűségű esemény. & $P(X=k) = p(1-p)^{k-1}$ \newline $k=1,2...$ & $\frac{1}{p}$ & $\frac{1-p}{p^2}$ \\ + \hline hipergeometriai \newline $Hipgeo(N,M,n)$ & Visszatevés nélküli mintavétel. & $P(X=k) = \frac{{M \choose k}{N-M \choose n-k}}{{N \choose n}}$ \newline $k=0,1,...,n$ & $n \frac{M}{N}$ & $n \frac{M}{N}(1 - \frac{M}{N})(1 - \frac{n-1}{N-1})$ \\ + \hline binomiális \newline $Bin(n,p)$ & Visszatevéses mintavétel. & $P(X=k) = {n \choose k}p^{k}(1-p)^{n-k}$ \newline $k=0,1,...,n$ & $np$ & $np(1-p)$ \\ + \hline negatív binomiális \newline $Negbin(n,p)$ & Hányadikra következik be $n.$ alkalommal egy $p$ valószínűségű esemény. & $P(X=k) = {k-1 \choose n-1}p^{n}(1-p)^{k-n}$ \newline $k=n,n+1,...$ & $\frac{n}{p}$ & $\frac{n(1-p)}{p^{2}}$ \\ + \hline Poisson \newline $Poi(\lambda)$ & Ritka esemény. & $P(X=k) = \frac{\lambda^k}{k!}e^{-\lambda}$ & $\lambda$ & $\lambda$ \\ + \hline +\end{tabular} + +\subsection{Folytonos valószínűségi változók} + +Egy $\xi$ valószínűségi változó abszolút folytonos, ha létezik olyan $f(x)$ függvény, amelyre $F(x) = \int_{-\infty}^{x}{f(t) dt}$. Ilyenkor $f(x)$ \textit{sűrűségfüggvény}. ($F(x)$ pedig az eloszlásfüggvény.) \\ +Másik megfogalmazás: $\forall a < b$-re $P(a < \xi < b) = \int_{a}^{b}{f(t)dt}$, $F_{\xi}(x) = P(\xi < x) = \lim\limits_{a \to -\infty}{P(a < \xi \ b)} = \int_{-\infty}^{x}{f(t)dt}$. \\ +Sűrűségfüggvény tulajdonságai: +\begin{enumerate} + \item $f(x) = F'(x)$ + \item $f(x) \geq 0$ + \item $\int_{-\infty}^{\infty}{f(x)dx} = 1$ +\end{enumerate} + +\begin{tabular}{|p{3cm}|c|c|c|c|} + \hline \textbf{Név} & \textbf{Eloszlásfüggvény} & \textbf{Sűrűségfüggvény} & \textbf{$EX$} & \textbf{$D^{2}X$} \\ + \hline egyenletes \newline $E(a,b)$ + & $\left\{\begin{array} {lr} + 0 & x \leq a \\ + \frac{x-a}{b-a} & a < x \leq b \\ + 1 & b < x + \end{array}\right.$ + & $\left\{\begin{array} {lr} + \frac{1}{b-a} & a < x \leq b \\ + 0 & otherwise + \end{array}\right.$ + & $\frac{a+b}{2}$ + & $\frac{(b-a)^2}{12}$ \\ + \hline exponenciális \newline $Exp(\lambda)$ + & $\left\{\begin{array} {lr} + 1 - e^{-\lambda x} & x \geq 0 \\ + 0 & otherwise + \end{array}\right.$ + & $\left\{\begin{array} {lr} + \lambda \cdot e^{-\lambda x} & x \geq 0 \\ + 0 & otherwise + \end{array}\right.$ + & $\frac{1}{\lambda}$ + & $\frac{1}{\lambda^{2}}$ \\ + \hline normális \newline $N(m,\sigma^2)$ & $...$ & $\frac{1}{\sqrt{2 \pi}\sigma}e^{-\frac{(x-m)^2}{2\sigma^2}}$ $x \in \mathbb{R}$ & $m$ & $\sigma^2$ \\ + \hline standard normális \newline $N(0,1^2)$ & $\Phi(x)=...$ & $\frac{1}{\sqrt{2 \pi}}e^{-\frac{x^2}{2}}$ $x \in \mathbb{R}$ & $0$ & $1$ \\ + \hline gamma \newline $\Gamma(\alpha,\lambda)$ + & $...$ + & $\left\{\begin{array} {lr} + \frac{1}{\Gamma(\alpha)}\lambda^{\alpha}x^{\alpha-1}e^{-\lambda x} & x \geq 0 \\ + 0 & otherwise + \end{array}\right.$ + & $\frac{\alpha}{\lambda}$ + & $\frac{\alpha}{\lambda^2}$ \\ + \hline +\end{tabular} + +\subsection{Fogalmak} + +\begin{itemize} + \item \textit{Konvolúció}: $X,Y$ független valószínűségi változók, konvolúciójuk az $X+Y$ v. v. + \item \textit{Függetlenség}: $P(\xi_10 \to$ pozitív, $R<0 \to$ negatív; $R^2 \sim 1 \to$ erős, $R^2 \sim 0.5 \to$ közepes, $R^2 \sim 0 \to$ gyenge. +\end{itemize} + +\section{Nagy számok törvénye} + +\subsection{Gyenge törvény} + +$X_1, X_2, ...$ függetlenek, azonos eloszlásúak, $EX_i = m < \infty$, $D^{2}X_i = \sigma^2 < \infty$. \\ +$P(\frac{X_1 + ... + X_n}{n} - m \geq \varepsilon) \rightarrow 0$ $(n \to \infty)$ $\forall \varepsilon > 0$-ra (sztochasztikus konvergencia). + +\subsection{Erős törvény} + +$X_1, X_2, ...$ függetlenek, azonos eloszlásúak, $EX_1 = m < \infty$, $D^{2}X_1 = \sigma^2 < \infty$. \\ +$\frac{X_1 + ... + X_n}{n} \rightarrow m$ $(n \to \infty)$ 1 valószínűséggel. \\ +Megjegyzés: Csebisev-egyenlőtlenséggel bizonyítjuk. ($\frac{\sigma^2}{n \varepsilon^2} \to 0$ $(n \to \infty)$) + +\subsubsection{Csebisev-egyenlőtlenség} + +$EX$ véges. \\ +Ekkor $P(|X-EX| \geq \lambda) \leq \frac{D^{2}X}{\lambda^2}$ \\ +Megjegyzés: Bizonyítás Markov-egyenlőtlenséggel. + +\subsubsection{Markov-egyenlőtlenség} + +$X \geq 0, c > 0$. \\ +Ekkor $P(X \geq c) \leq \frac{EX}{c}$ + +\subsection{Konvergenciafajták} + +$\xi_n \to \xi$, vagyis $\xi$ konvergens. +\begin{itemize} + \item \textit{sztochasztikusan}: ha $\forall \varepsilon > 0$-ra $P(|\xi_n - \xi| \geq \varepsilon) \rightarrow 0$ $(n \to \infty)$. + \item \textit{1 valószínűséggel (majdnem mindenütt)}: ha $P(\omega : \xi_n(\omega) \to \xi(\omega)) = 1$. + \item \textit{$L^p$-ben}: ha $E(|\xi_n - \xi|^p) \rightarrow 0$ $(n \to \infty)$ ($p>0$ rögzített). + \item \textit{eloszlásban}: ha $F_{\xi_n}(x) \rightarrow F_{\xi}(x)$ $(n \to \infty)$ az utóbbi minden folytonossági pontjában. +\end{itemize} +\textit{Kapcsolataik}: 1 valószínűségű és $L^p$-beli a legerősebb, ezekből következik a sztochasztikus, ebből pedig az eloszlásbeli. + +\section{Centrális határeloszlás tétel} + +$X_1, X_2, ...$ függetlenek, azonos eloszlásúak, $EX_1 = m < \infty$, $D^{2}X_1 = \sigma^2 < \infty$. \\ +Ekkor $\frac{X_1 + ... + X_n - nm}{\sqrt{n}\sigma} \rightarrow N(0,1)$ $(n \to \infty)$ eloszlásban, azaz $P(\frac{X_1 + ... + X_n - nm}{\sqrt{n}\sigma} < x) \rightarrow \Phi(x)$ $(n \to \infty)$. + +\section{Statisztikai mező} + +$(\Omega, \mathcal{A}, \mathcal{P})$ hármas, ha $\mathcal{P} = \{P_{\vartheta}\}_{\vartheta \in \Theta}$ és $(\Omega, \mathcal{A}, P_{\vartheta})$ Kolmogorov-féle valószínűségi mező $\forall \vartheta \in \Theta$-ra. + +\subsection{Fogalmak} + +\begin{itemize} + \item \textit{Minta}: $\underline{\xi} = (\xi_1,...,\xi_n): \Omega \to \Xi \in \mathbb{R}^n$. ($\xi_i$ valószínűségi változó) + \item \textit{Mintatér}: $\Xi$, minta lehetséges értékeinek halmaza, gyakran $\mathbb{R}^n, \mathbb{Z}^n$. + \item \textit{Minta [realizációja]}: $\underline{x} = (x_1,...,x_n)$, konkrét megfigyelés. + \item \textit{Statisztika}: $T: \Xi \to \mathbb{R}^k$. + \item \textit{Statisztika alaptétele}: (Glivenko--Cantelli-tétel) $\xi_1, \xi_2, ...$ független, azonos eloszlású $F$ eloszlásfüggvénnyel. Ekkor az $F_n$ tapasztalati eloszlásfüggvényre teljesül, hogy $\sup_{-\infty u_{1-\frac{\varepsilon}{2}}$, és elfogadjuk, ha $|u| \leq u_{1-\frac{\varepsilon}{2}}$. \\ + Egyoldali esetben $u > u_{1-\varepsilon}$ (jobb) és $u < u_{1-\varepsilon}$ (bal) esetét vizsgáljuk, ezen esetekben utasítjuk el $H_0$-t. + \item \textit{Kétmintás}: Itt a feltételek a következők: $\xi_i \sim N(m_1, \sigma_1^2)$, $i=1..n$ és $\eta_j \sim N(m_2, \sigma_2^2)$, $j=1..m$. A szórások szintén ismertek. $H_0: m_1 = m_2$, és $u = \frac{\overline{\xi} - \overline{\eta}}{\sqrt{\frac{\sigma_1^2}{n} + \frac{\sigma_2^2}{m}}}$. $H_1 : m_1 > m_2$, ez a felső (jobb?) oldali, $H_1 : m_1 < m_2$ pedig az alsó (bal?) ellenhipotézis. + \end{itemize} + \item \textit{t-próba}: Ennél a próbánál nem ismert a szórás, viszont ugyanúgy normális eloszlást feltételezünk, mint az u-próbánál. $\xi_i \sim N(m, \sigma^2)$, $i=1..n$. + \begin{itemize} + \item \textit{Egymintás}: $H_0: m = m_0$. Ellenhipotézis az u-próbához hasonlóan. $t = \sqrt{n}\frac{\overline{\xi} - m_0}{\sqrt{\sigma_{*}^2}}$, ahol $\sigma_{*}^2$ a korrigált tapasztalati szórásnégyzet, amit a mintából számíthatunk ki. (Megjegyzés: $n$ helyett $n-1$-gyel osztunk a képletben.) Ez az érték $t$-eloszlású $H_0$ esetén, ami $n-1$ szabadságfokú. Más néven szokás ezt a próbát Student-próbának is nevezni. + \item \textit{Kétmintás}: $\xi_i \sim N(m_1, \sigma_1^2)$, $i=1..n$ és $\eta_j \sim N(m_2, \sigma_2^2)$, $j=1..m$. Ez esetben sem ismert a szórás, viszont feltételezzük, hogy a két minta szórása megegyezik. Ekkor $t_{n+m-2} = \sqrt{\frac{nm(n+m-2)}{n+m}}\frac{\overline{\xi} - \overline{\eta}}{\sqrt{\sum{(\xi_i - \overline{\xi})^2} + \sum{(\eta_j - \overline{\eta})^2}}}$. $n+m-2$ a próba szabadságfoka. + \end{itemize} + \item \textit{f-próba}: Két minta esetén használható. Ez a próba szórások egyezőségének vizsgálatára alkalmas, tehát itt $H_0 : \sigma_1 = \sigma_2$. Ha a két minta szórásnégyzete megegyezik, akkor a hányadosuk $1$-hez tart. $f_{n-1,m-1} = max(\frac{\sigma_1^2}{\sigma_2^2}, \frac{\sigma_2^2}{\sigma_1^2})$. A két szabadsági fok közül az első az $f$ számlálójához tartozó minta elemszáma $- 1$, a második a nevezőjéhez. + \item \textit{Welch-próba}: Más néven d-próba. Hasonló, mint a kétmintás t-próba, de itt a szórások egyezőségét nem kell feltenni. Szabadsági foka bonyolult képlettel számítható. + \item \textit{szekvenciális próbák}: $V_n = \frac{\prod{f_1(x_i)}}{\prod{f_0(x_i)}} = \frac{L_1(\underline{x})}{L_0(\underline{x})}$. $f_0$ a nullhipotézis szerinti sűrűségfüggvény, $f_1$ az ellenhipotézis szerinti. Adott egy $A$ és egy $B$ érték, $A Y) = \frac{1}{2}$ tesztelésére összeszámoljuk, hogy hány párra teljesül, hogy $X_i > Y_j$. + \end{itemize} +\end{itemize} + +\end{document} diff --git a/6. Mesterséges intelligencia/6. Mesterséges intelligencia.pdf b/6. Mesterséges intelligencia/6. Mesterséges intelligencia.pdf new file mode 100644 index 0000000..96851c6 Binary files /dev/null and b/6. Mesterséges intelligencia/6. Mesterséges intelligencia.pdf differ diff --git a/6. Mesterséges intelligencia/6. Mesterséges intelligencia.tex b/6. Mesterséges intelligencia/6. Mesterséges intelligencia.tex new file mode 100644 index 0000000..03031aa --- /dev/null +++ b/6. Mesterséges intelligencia/6. Mesterséges intelligencia.tex @@ -0,0 +1,126 @@ +\documentclass[margin=0px]{article} + +\usepackage{listings} +\usepackage[utf8]{inputenc} +\usepackage{graphicx} +\usepackage{float} +\usepackage[a4paper, margin=0.7in]{geometry} +\usepackage{amsthm} +\usepackage{amssymb} +\usepackage{t1enc} +\usepackage{fancyhdr} +\usepackage{setspace} + +\onehalfspacing + +\newenvironment{tetel}[1]{\paragraph{#1 \\}}{} + +\pagestyle{fancy} +\lhead{\it{PTI BSc Záróvizsga tételek}} +\rhead{6. Mesterséges intelligencia} + +\title{\textbf{{\Large ELTE IK - Programtervező Informatikus BSc} \vspace{0.2cm} \\ {\huge Záróvizsga tételek}} \vspace{0.3cm} \\ 6. Mesterséges intelligencia} +\author{} +\date{} + +\begin{document} +\maketitle + +\begin{tetel}{Mesterséges intelligencia} + MI problémák és az útkeresési feladat kapcsolata. Modellezési technikák (pl. állapottér modell, dekompozíciós modell). Heurisztikus útkereső algoritmusok: lokális keresések (hegymászó módszer, tabu-keresés, szimulált hűtés), visszalépéses keresés, heurisztikus gráfkereső eljárások (A, A*, $A^C$, B algoritmusok). Kétszemélyes játékok. +\end{tetel} + +\section{Bevezetés} + +Az MI az intelligens gondolkodás számítógépes reprodukálása szempontjából hasznos elveket, módszereket, technikákat kutatja, fejleszti, rendszerezi. Megoldandó feladatai: nehezek, mert ezek problématere hatalmas, a megoldás megkeresése kellő intuíció hiányában kombinatorikus robbanáshoz vezethet. A szoftver intelligensen viselkedik, és sajátos eszközöket használ. A reprezentáció átgondolt a feladat modellezéséhez, és az algoritmusok hatékonyak, heurisztikával megerősítve. + +\section{Útkeresési problémák} + +Útkeresési problémaként sok MI feladat fogalmazható meg úgy, hogy a feladat modellje alapján megadunk egy olyan élsúlyozott irányított gráfot, amelyben adott csúcsból adott csúcsba vezető utak jelképezik a feladat egy-egy megoldását. Ezt a feladat \textit{gráfreprezentációjának} is szokás nevezni, amely magába foglal egy úgynevezett \textit{$\delta$-gráfot} (olyan élsúlyozott irányított gráf, ahol egy csúcsból kivezető élek száma véges, és az élek költségére megadható egy $\delta$ pozitív alsó korlát), az abban kijelölt startcsúcsot és egy vagy több célcsúcsot. Ebben a reprezentációs gráfban keresünk egy startcsúcsból kiinduló célcsúcsba futó utat, esetenként egy legolcsóbb ilyet. + +\section{Modellezési technikák} +\subsection{Állapottér-reprezentáció} + +Állapottér-reprezentáció egy olyan lehetséges (de nem az egyetlen) módszer a feladatok modellezésére, amelyet aztán természetes módon lehet gráfreprezentációkét is megfogalmazni. Négy eleme van: +\begin{itemize} + \item \textit{Állapottér}, amely a probléma homlokterében álló adat (objektum) lehetséges értékeinek (állapotainak) halmaza. Gyakran egy alaphalmaz, amelyet egy alkalmas invariáns leszűkít. + \item \textit{Műveletek} (előfeltétel+hatás), amelyek állapotból állapotba vezetnek. + \item \textit{Kezdőállapot}(ok) vagy azokat leíró kezdőfeltétel. + \item \textit{Célállapot}(ok) vagy célfeltétel. +\end{itemize} +Az \textit{állapot-gráf} (egy speciális reprezentációs gráf) az állapotokat, mint csúcsokat, a műveletek hatásait, mint éleket tartalmazza. +Az állapottér nem azonos a problématérrel, hiszen a problématér elemei a startcsúcsból kivezető utak (műveletsorozatok), nem pedig az állapotok (csúcsok). A megoldás a problématér egy eleme, ami egy olyan műveletsorozat, ami startcsúcsból célcsúcsba vezet. + +\subsection{Dekompozíciós modell} +A probléma dekompozíciólényege az, hogy egy feladatot részfeladatokra bontunk, majd azokat tovább részletezzük, amíg nyilvánvalóan megoldható feladatokat nem kapunk. A reprezentációhoz meg kell adnunk: +\begin{itemize} + \item a feladat részproblémáinakáltalános leírását, + \item az eredeti problémát, + \item az egyszerű problémákat, amelyekről könnyen eldönthető, hogy megoldhatók-e vagy sem, és + \item a dekomponálóműveleteket: +\end{itemize} +Dekomponálóműveleteket nagyon nehéz megtalálni: +\begin{itemize} + \item Nem biztos, hogy megtaláljuk. + \item Hamis dekomponálóműveletek. + \item Nem minden feladat dekomponálható. +\end{itemize} +Az egyszerű probléma felismerése sem egyértelmű. A megoldás kiolvasása sem nyilvánvaló. +Egy dekompozíciós eprezentációhoz tartozó $( R, s, T )$ gráfreprezentációban +\begin{itemize} + \item az $R = ( N, A, c )$ egy olyan ÉS/VAGY gráf (dekompozíciósgráfban), ahol + \item {\it N} a részprobémákat, + \item {\it A} a dekomponálóműveleteket, + \item {\it c} azok költségeit szimbolizálják, + \item {\it s} az eredeti problémát, + \item {\it T} az egyszerű problémákat jelöli. +\end{itemize} + +A probléma megoldását egy s $\rightarrow$ M $\subseteq$ T közönséges irányított kört nem tartalmazó hiperút, az úgynevezett megoldásgráf megtalálása jelenti. Az eredeti probléma megoldása ebből a megoldásgráfból nyerhető ki. A megoldás költsége többnyire nem függ a megoldásgráf költségétől, ezért nem cél az optimális megoldásgráf előállítása. + +\section{Keresések} + +Egy általános \textit{kereső rendszer} részei: a \textit{globális munkaterület} (a keresés memóriája), a \textit{keresési szabályok} (a memória tartalmát változtatják meg), és a \textit{vezérlési stratégia} (adott pillanatban alkalmas szabályt választ). A vezérlési stratégiának van egy általános, elsődleges eleme (ez lehet nemmódosítható vagy módosítható), lehet egy másodlagos (az alkalmazott reprezentációs modell sajátosságait kihasználó) eleme és a konkrét feladatra építő eleme. Ez utóbbi a \textit{heurisztika}, a konkrét feladatból származó extra ismeret, amelyet közvetlenül a vezérlési stratégiába építünk be az eredményesség és a hatékonyság javítása céljából. + +\section{Lokális keresések} + +A lokális keresések egyetlen aktuális csúcsot és annak szűk környezetét tárolják a globális munkaterületen. Keresési szabályai az aktuális csúcsot minden lépésben a szomszédjai közül vett lehetőleg ,,jobb” gyerekcsúccsal cserélik le. A vezérlési stratégiájuk a ,,jobbság” eldöntéséhez egy \textit{rátermettségi függvényt} használ, amely annál jobb értéket ad egy csúcsra, minél közelebb esik az a célhoz. Mivel a keresés ,,elfelejti”, hogy honnan jött, a döntések nem vonhatók vissza, ez egy \textit{nem-módosítható vezérlési stratégia}. +Lokális kereséssel megoldható feladatok azok, ahol egy lokálisan hozott rossz döntés nem zárja ki a cél megtalálását. Ehhez vagy egy erősen összefüggő reprezentációs-gráf, vagy jó heurisztikára épített +célfüggvény kell. Jellemző alkalmazás: adott tulajdonságú elem keresése, függvény optimumának keresése. +\begin{itemize} + \item \textit{Hegymászó algoritmus}: Minden lépésben az aktuális csúcs legjobb gyermekére lép, de kizárja a szülőre való visszalépést. Zsákutcába (aktuális csúcsból nem vezet ki él) beragad, körök mentén végtelen ciklusba kerülhet, ha a rátermettségi függvény nem tökéletes. + \item \textit{Tabu keresés}: Az aktuális csúcson (n) kívül nyilvántartja még az eddig legjobbnak bizonyult csúcsot (n*) és az utolsó néhány érintett csúcsot; ez a (sor tulajdonságú) tabu halmaz. Minden lépésben az aktuális csúcs gyermekei közül, kivéve a tabu halmazban levőket, a legjobbat választja új aktuális csúcsnak, (ezáltal felismeri a tabu halmaz méreténél nem nagyobb köröket), frissíti a tabu halmazt, és ha n jobb, mint az n*, akkor n*-ot lecseréli n-re. + \item \textit{Szimulált hűtés algoritmusa}: A következő csúcs választása véletlenszerű. Ha a kiválasztott csúcs (r) célfüggvény-értéke jobb, mint az aktuális csúcsé (n), akkor odalép, ha rosszabb, akkor az új csúcs elfogadásának valószínűsége fordítottan arányos f(n) - f(r) különbséggel. Ez az arány ráadásul folyamatosan változik a keresés során: ugyanolyan különbség esetén kezdetben nagyobb, később kisebb valószínűséggel fogja a rosszabb értékű r csúcsot választani. +\end{itemize} + +\section{Visszalépéses keresések} + +A startcsúcsból az aktuális csúcsba vezető utat (és az arról leágazó még ki nem próbált éleket) tartja nyilván (globális munkaterületen), a nyilvántartott út végéhez egy új (ki nem próbált) élt fűzhet vagy a legutolsó élt törölheti (visszalépés szabálya), a visszalépést a legvégső esetben alkalmazza. A visszalépés teszi lehetővé azt, hogy egy korábbi továbblépésről hozott döntés megváltozhasson. Ez tehát egy \textit{módosítható vezérlési stratégia}. A keresésbe sorrendi és vágó heurisztika építhető. Mindkettő lokálisan, az aktuális csúcsból kivezető, még ki nem próbált élekre vonatkozik. +Visszalépés feltételei: zsákutca, zsákutca torkolat, kör, mélységi korlát. +\begin{itemize} + \item VL1 (nincs kör- és mélységi korlát figyelés) véges körmentes irányított gráfokon terminál, és ha van megoldás, akkor talál egyet. + \item VL2 (általános) $\delta$-gráfokon terminál, és ha van megoldás a mélységi korláton belül, akkor talál egyet. +\end{itemize} +Könnyen implementálható, kicsi memória igényű, mindig terminál, és ha van (a mélységi korlát alatt), akkor megoldást talál. De nem garantál optimális megoldást, egy kezdetben hozott rossz döntést csak nagyon sok lépés után képes korrigálni és egy zsákutca-szakaszt többször is bejárhat, ha abba többféle úton is el lehet jutni. + +\section{Gráfkeresések} + +A globális munkaterületén a startcsúcsból kiinduló már feltárt utak találhatók (ez az ún. \textit{kereső gráf}), külön megjelölve az utak azon csúcsait, amelyeknek még nem (vagy nem eléggé jól) ismerjük a rákövetkezőit. Ezek a \textit{nyílt csúcsok}. A keresés szabályai egy nyílt csúcsot terjesztenek ki, azaz előállítják (vagy újra előállítják) a csúcs összes rákövetkezőjét. A vezérlési stratégia a legkedvezőbb nyílt csúcs kiválasztására törekszik, ehhez egy \textit{kiértékelő függvényt} (f) használ. Mivel egy nyílt csúcs, amely egy adott pillanatban nem kerül kiválasztásra, később még kiválasztódhat, ezért itt egy módosítható vezérlési stratégia valósul meg. +A keresés minden csúcshoz nyilvántart egy odavezető utat (\textbf{$\pi$} visszamutató pointerek segítségével), valamint az út költségét (g). Ezeket az értékeket működés közben alakítja ki, amikor a csúcsot először felfedezi vagy később egy olcsóbb utat talál hozzá. Mindkét esetben (amikor módosultak a csúcs ezen értékei) a csúcs nyílttá válik. Amikor egy már korábban kiterjesztett csúcs újra nyílt lesz, akkor a már korábban felfedezett leszármazottainál a visszafelé mutató pointerekkel kijelölt út költsége nem feltétlenül egyezik majd meg a nyilvántartott g értékkel, és az sem biztos, hogy ezek az értékek az eddig talált legolcsóbb útra vonatkoznak, vagyis előfordulhat, hogy elromlik a keresőgráf korrektsége. +\begin{itemize} + \item Nem-informált gráfkeresések: \textit{mélységi gráfkeresés} ($f = -g$, minden $(n,m)$ élre $c(n,m)=1$), \textit{szélességi gráfkeresés} ($f = g$, $c(n,m)=1$), \textit{egyenletes gráfkeresés} ($f = g$) + \item Heurisztikus gráfkeresések f-je a h heurisztikus függvényre épül, amely minden csúcsban a hátralevő optimális h* költséget becsli. Ilyen az \textit{előre tekintő gráfkeresés} ($f = h$), az \textit{A algoritmus} ($f = g+h, h \geq 0$), az \textit{A* algoritmus} ($f = g+h, h^* \geq h \geq 0$ – h megengedhető), az \textit{$A^C$ algoritmus} ($f = g+h, h^* \geq h \geq 0$, minden $(n,m)$ élre $h(n)-h(m) \leq c(n,m)$), és \textit{B algoritmus} (ahol az $f= g+h$, $h \geq 0$ helyett a g-t használjuk a kiterjesztendő csúcs kiválasztására azon nyílt csúcsok közül, amelyek f értéke kisebb, mint az eddig kiterjesztett csúcsok f értékeinek maximuma). +\end{itemize} +Véges $\delta$-gráfokon minden gráfkeresés terminál, és ha van megoldás, talál egyet. A nevezetes gráfkeresések többsége végtelen nagy gráfokon is találnak megoldást, ha van megoldás. (Kivétel az előre-tekintő keresés és a mélységi korlátot nem használó mélységi gráfkeresés.) +Az A*, $A^C$ algoritmusok optimális megoldást találnak, ha van megoldás. Az $A^C$ algoritmus egy csúcsot legfeljebb egyszer terjeszt csak ki. +Egy gráfkeresés memória igényét a kiterjesztett csúcsok számával, futási idejét ezek kiterjesztéseinek számával mérjük. (Egy csúcs általában többször is kiterjesztődhet, de $\delta$-gráfokban csak véges sokszor.) A* algoritmusnál a futási idő legrosszabb esetben exponenciálisan függ a kiterjesztett csúcsok számától, de ha olyan heurisztikát választunk, amelyre már $A^C$ algoritmust kapunk, akkor a futási idő lineáris lesz. Persze ezzel a másik heurisztikával változik a kiterjesztett csúcsok száma is, így nem biztos, hogy egy $A^C$ algoritmus ugyanazon a gráfon összességében kevesebb kiterjesztést végez, mint egy csúcsot többször is kiterjesztő A* algoritmus. A B algoritmus futási ideje négyzetes, és ha olyan heurisztikus függvényt használ, mint az A* algoritmus (azaz megengedhetőt), akkor ugyanúgy optimális megoldást talál (ha van megoldás) és a kiterjesztett csúcsok száma (mellesleg a halmaza is) megegyezik az A* algoritmus által kiterjesztett csúcsokéval. + +\section{Kétszemélyes (teljes információjú, zéró összegű, véges) játékok} + +A játékokat állapottér-reprezentációval szokás leírni, és az állapot-gráfot faként ábrázolják. +A \textit{győztes (vagy nem-vesztes) stratégia} egy olyan elv, amelyet betartva egy játékos az ellenfél minden lépésére tud olyan választ adni, hogy megnyerje (ne veszítse el) a játékot. Valamelyik játékosnak biztosan van győztes (nem-vesztes) stratégiája. Győztes (nem-vesztes) stratégia keresése a \textit{játékfában} kombinatorikus robbanást okozhat, ezért e helyett részfa kiértékelést szoktak alkalmazni a soron következő jó lépés meghatározásához. +A \textit{minimax} algoritmus az aktuális állásból felépíti a játékfa egy részét, kiértékeli annak leveleit aszerint, hogy azok által képviselt állások milyen mértékben kedveznek nekünk vagy az ellenfélnek, majd szintenként váltakozva az ellenfél szintjein a gyerekcsúcsok értékeinek minimumát, a saját szintjeinken azok maximumát futtatjuk fel a szülőcsúcshoz. Ahonnan a gyökérhez kerül érték, az lesz soron következő lépésünk. +A minimax legismertebb módosítása az \textit{alfa-béta} algoritmus, amely egyfelől kisebb memória igényű (egyszerre csak egy ágat tárol a vizsgált részfából), másfelől egy sajátos vágási stratégia miatt jóval kevesebb csúcsot vizsgál meg, mint a minimax. Saját szinten $\alpha$, ellenfelén $\beta$ értéket adunk meg, kezdetben $-\infty$, illetve $+\infty$ értékkel. Visszalépéskor változtatunk rajta, $\alpha$-t növeljük, $\beta$-t csökkentjük. Vágás akkor történik, ha az úton vannak olyan értékek, hogy $\alpha \geq \beta$. +További módosítások még az átlagoló (legnagyobb m és legkisebb n darab érték átlagát vesszük), illetve a váltakozó mélységű kiértékelésű minimax (minden ágon reális értéket mutasson a kiértékelő függvény nyugalmi teszttel), továbbá a negamax algoritmus (ellenfél szintjén (-1)-szeres érték, maximumot választunk minden szinten az ellentettekből). + +\end{document} \ No newline at end of file diff --git a/7. Programozás/7. Programozás.pdf b/7. Programozás/7. Programozás.pdf new file mode 100644 index 0000000..3d23364 Binary files /dev/null and b/7. Programozás/7. Programozás.pdf differ diff --git a/7. Programozás/7. Programozás.tex b/7. Programozás/7. Programozás.tex new file mode 100644 index 0000000..72473ca --- /dev/null +++ b/7. Programozás/7. Programozás.tex @@ -0,0 +1,534 @@ +\documentclass[margin=0px]{article} + +\usepackage{listings} +\usepackage[utf8]{inputenc} +\usepackage{graphicx} +\usepackage{float} +\usepackage[a4paper, margin=0.7in]{geometry} +\usepackage{amsthm} +\usepackage{amssymb} +\usepackage{amsmath} +\usepackage{fancyhdr} +\usepackage{pdfpages} +\usepackage{setspace} + +\onehalfspacing + +\newenvironment{tetel}[1]{\paragraph{#1 \\}}{} +\renewcommand{\figurename}{ábra} +\makeatletter +\renewcommand\paragraph{% + \@startsection{paragraph}{4}{0mm}% + {-\baselineskip}% + {.5\baselineskip}% + {\normalfont\normalsize\bfseries}} +\makeatother + +\pagestyle{fancy} +\lhead{\it{PTI BSc Záróvizsga tételek}} +\rhead{7. Programozás} + +\title{\textbf{{\Large ELTE IK - Programtervező Informatikus BSc} \vspace{0.2cm} \\ {\huge Záróvizsga tételek}} \vspace{0.3cm} \\ 7. Programozás} +\author{} +\date{} + +\begin{document} +\maketitle + +\begin{tetel}{Programozás} + A felsoroló fogalma. Nevezetes gyűjtemények (intervallum, tömb, sorozat, szekvenciális inputfájl) felsorolói. Felsorolóra megfogalmazott programozási tételek (összegzés, számlálás, maximum kiválasztás, feltételes maximumkeresés, lineáris keresés, kiválasztás). A visszavezetés módszere. Programozási tételekkel készült programok tesztelése. +\end{tetel} + +\section{Egyszerű programozási feladat megoldásának lépései} +\subsection{Bevezetés} +Egy programozási feladat megoldása a kódoláson túl jó néhány tevékenységet tartalmaz. +Az első teendő a feladat pontos meghatározása, a specifikáció. Ez a feladat szöveges és formalizált, matematikai leírásán (a specifikáció ún. szűkebb értelmezésén) túl tartalmazza a megoldással szemben támasztott követelményeket, környezeti igényeket is (ami a specifikáció ún. tágabb értelmezése). + +A specifikáció alapján meg lehet tervezni a programot, elkészülhet a megoldás algoritmusa és az algoritmus által használt adatok leírása. Az algoritmus és az adatszerkezet finomítása egymással párhuzamosan halad, egészen addig a szintig, amelyet a programozó ismeretei alapján már könnyen, hibamentesen képes kódolni. Gyakran előfordul, hogy a tervezés során derül fény a specifikáció hiányosságaira, így itt visszalépésekre számíthatunk. + +Az algoritmusírás után következhet a kódolás. Ha a feladat kitűzője nem rögzítette, akkor ez előtt választhatunk a megoldáshoz programozási nyelvet. A kódolás eredménye a programozási nyelven leírt program. + +A program első változatban általában sohasem hibátlan, a helyességéről csak akkor beszélhetünk, ha meggyőződtünk róla. A helyesség vizsgálatának egyik lehetséges módszere a tesztelés. Ennek során próbaadatokkal próbáljuk ki a programot, s az ezekre adott eredményből következtetünk a helyességre. (Ne legyenek illúzióink afelől, hogy teszteléssel eldönthető egy program helyessége. Hisz hogy valójában helyes-e a program – sajnos – nem következik abból, hogy nem találtunk hibát.) + +Ha a tesztelés során hibajelenséggel találkozunk, akkor következhet a hibakeresés, a hibajelenséget okozó utasítás megtalálása, majd pedig a hibajavítás. A hiba kijavítása több fázisba is visszanyúlhat. Elképzelhető, hogy kódolási hibát kell javítanunk, de az is lehet, hogy a hibát már a tervezésnél követtük el. Javítás után újra tesztelni kell, hiszen – legyünk őszinték magunkhoz!– nem kizárt, hogy hibásan javítunk, illetőleg – enyhe optimizmussal állítjuk:– a javítás újabb hibákat fed fel, ... + +E folyamat végeredménye a helyes program. Ezzel azonban még korántsem fejeződik be a programkészítés. Most következnek a minőségi követelmények. Egyrészt a hatékonyságot kell vizsgálnunk (végrehajtási idő, helyfoglalás), másrészt a kényelmes használhatóságot. Itt újra visszaléphetünk a kódolási, illetve a tervezési fázisba is. Ezzel elérkeztünk a jó programhoz. + +\subsection{Specifikáció} +A programkészítés menetének első lépése a feladat meghatározása, precíz "újrafogalmazása". Milyen is legyen, mit várjunk el tőle? Nézzünk meg néhány – jónak tűnő – követelményt egyelőre címszavakban! (A továbbiakban a specifikáció szűkebb értelmezéséről lesz szó.) A specifikáció legyen: + +\begin{itemize} + \item helyes, egyértelmű, pontos, teljes + \item rövid, tömör, ami legegyszerűbben úgy érhető el, hogy ismert formalizmusokra építjük + \item szemléletes, érthető (amit időnként nehezít a formalizáltság) +\end{itemize} + +A specifikáció első közelítésben lehetne a feladatok szövege. Ez azonban több problémát vethet fel: + +\begin{itemize} + \item mi alapján adjuk meg a megoldást + \item mit is kell pontosan megadni? +\end{itemize} + +Például az a feladat, hogy adjuk meg N ember közül a legmagasabbat. A legmagasabb ember megadása mit jelent? Adjuk meg a sorszámát, vagy a nevét, vagy a személyi számát, vagy a magasságát, esetleg ezek közül mindegyiket? +Tanulságként megállapíthatjuk, hogy a specifikációnak tartalmaznia kell a bemenő és a kimenő adatok leírását. + +\begin{verbatim} + Bemenet: + N : az emberek száma, + A : a magasságukat tartalmazó sorozat. + + Kimenet: + MAX : a legmagasabb ember sorszáma. + \end{verbatim} + + +Tudjuk-e, hogy a bemenő, illetve a kimenő változók milyen értéket vehetnek fel? Például az emberek magasságát milyen mértékegységben kell megadni? Az eredményül kapott sorszám milyen érték lehet: 1-től sorszámozunk, vagy 0-tól? Megállapíthatjuk tehát, hogy a specifikációban a bemeneti és a kimeneti változók értékhalmazát is meg kell adnunk. + +\begin{verbatim} + Bemenet: + N : az emberek száma, természetes szám; + A : a magasságukat tartalmazó sorozat, egész számok, amelyek a magasságot + centiméterben fejezik ki (a sorozatot 1-től N-ig indexeljük). + Kimenet: + MAX : a legmagasabb ember sorszáma, 1 és N közötti természetes szám. + \end{verbatim} + +Most már a bemenő és a kimenő változók értékhalmazát pontosan meghatároztuk, csupán az a probléma, hogy a feladatban használt fogalmakat és az eredmények kiszámítási szabályát nem definiáltuk. A specifikációnak tehát tartalmaznia kell a feladatban használt fogalmak definícióját, valamint az eredmény kiszámítási szabályát. Itt lehetne megadni a bemenő adatokra vonatkozó összefüggéseket is. A bemenő, illetve a kimenő adatokra kirótt feltételeket nevezzük előfeltételnek, illetve utófeltételnek. Az előfeltétel nagyon sokszor egy azonosan igaz állítás, azaz a bemenő adatok értékhalmazát semmilyen "külön” feltétellel nem szorítjuk meg. + +\begin{verbatim} + Bemenet: + N : az emberek száma, természetes szám, + A : a magasságukat tartalmazó sorozat, egész számok, + amelyek a magasságot centiméterben tartalmazzák (a sorozatot 1-tol N-ig indexeljük). + Kimenet: + MAX : a legmagasabb ember sorszáma, 1 és N közötti természetes szám. + + Elofeltétel: + A[i]-k pozitívak. + + Utófeltétel: + MAX olyan 1 és N közötti szám, amelyre A[MAX] nagyobb vagy egyenlo, + mint a sorozat bármely eleme (az 1. és az N. között). + \end{verbatim} + +Újabb probléma merülhet fel bármelyik feladattal kapcsolatban: az eddigiek alapján a "várttól” lényegesen különböző – nyugodtan állíthatjuk: "banális” –, az elő- és utófeltételnek megfelelő megoldást is tudunk készíteni. + +Itt persze arról a hallgatólagos (tehát még meg nem fogalmazott, ki nem mondott) feltételezésről van szó, hogy a bemeneti változók értéke nem változik meg. Ez sajnos nem feltétlenül igaz. A probléma megoldására kétféle utat követhetünk (a későbbiekben mindkettőt alkalmazni fogjuk): + +\begin{itemize} + \item az utófeltételbe automatikusan beleértjük, hogy "és a bemeneti változók értéke nem változik meg”, s külön kiemeljük, ha mégsem így van; + \item az elő- és az utófeltételt a program paramétereire fogalmazzuk meg, amelyeket formailag megkülönböztetünk a program változóitól, és emiatt nem a paraméterek fognak változni, hanem a programbeli változók (ebben az esetben természetesen az elő- és az utófeltételben meg kell fogalmazni a paraméterek és a megfelelő programbeli változók értékének azonosságát). +\end{itemize} + +A második megoldásból az következik, hogy meg kell különböztetnünk egymástól a feladat és a program elő–, illetve utófeltételét! Ez hosszadalmasabbá – bár precízebbé – teszi a feladat megfogalmazását, emiatt ritkábban fogjuk alkalmazni. + +Előfordulhat, hogy a feladat megfogalmazása alapján nem lehet egyértelműen meghatározni az eredményt, ugyanis az utófeltételnek megfelelő több megoldás is létezik. Ez a jelenség a feladat ún. nemdeterminisztikussága. Ehhez a nemdeterminisztikus feladathoz tehát determinisztikus programot kell írnunk, aminek az utófeltétele már nem engedheti meg a nem egyértelműséget, a nemdeterminisztikusságot. E probléma miatt tehát mindenképpen meg kell különböztetnünk egymástól a feladat és a program elő–, illetve utófeltételét! + +\begin{verbatim} + Bemenet: + N : az emberek száma, természetes szám, + A : a magasságukat tartalmazó sorozat, egész számok, + amelyek a magasságot centiméterben tartalmazzák (a sorozatot 1-tol N-ig indexeljük). + Kimenet: + MAX : a legmagasabb ember sorszáma, 1 és N közötti természetes szám. + + Elofeltétel: + A[i]-k pozitívak. + + Utófeltétel: + MAX olyan 1 és N közötti szám, amelyre A[MAX] nagyobb vagy egyenlo, + mint a sorozat bármely eleme (az 1. és az N. között). + + Program utófeltétel: + MAX olyan 1 és N közötti szám, amelyre A[MAX] nagyobb vagy egyenlo, + mint a sorozat bármely eleme (az 1. és az N. között) és elotte + nincs vele egyenlo. + \end{verbatim} + +Megállapíthatjuk ebből, hogy a program utófeltétele lehet szigorúbb, mint a feladaté, emellett az előfeltétele pedig lehet gyengébb. + +Visszatekintve a specifikáció eddig "bejárt pályájára” egy szemléletes modellje körvonalazódik a feladatmegoldásnak. Nevezetesen: nyugodtan mondhatjuk azt, hogy a feladatot megoldó program egy olyan automatát határoz meg, amelynek pillanatnyi állapota a feladat paraméterei (a program változói) által "kifeszített” halmaz egy eleme. (E halmaz annyi dimenziós, ahány paraméterváltozója van a programnak; minden dimenzió egyik változó értékhalmaza. Tehát egy konkrét időpillanatban e "gép” állapota: a változóinak abban a pillanatban érvényes értékeinek együttese.) Ezt a halmazt nevezzük a program állapotterének. Amikor megfogalmazzuk az előfeltételt, akkor tulajdonképpen kihasítjuk ebből az állapottérből azt a részt (azt az altért), amelyből indítva elvárhatjuk az automatánktól (amit a megoldó program vezérel), hogy a helyes eredményt előállítja egy végállapotában. A végállapotot jelöltük ki az utófeltétellel. + +Ezt a modellt elfogadva adódik még egy további megoldásra váró kérdés. Akkor ugyanis, amikor a programot írjuk, lépten-nyomon a részeredmények tárolására újabb és újabb változókat vezetünk be. Fölvetődik a kérdés: hogyan egyeztethető össze az imént elképzelt modellel? A válasz egyszerű: minden egyes újabb változó egy újabb dimenziót illeszt az eddig létrejött állapottérhez. Tehát a programozás folyamata – leegyszerűsítve a dolgot – nem áll másból, mint annak pontosításából, hogy hogyan is nézzen ki a megoldó automata állapottere (és persze: hogyan kell az egyik állapotból a másik állapotba jutnia). A feladatban szereplő paraméterek meghatározta "embrionális” állapotteret hívhatjuk paramétertérnek, ami csak altere a program valódi állapotterének. Ez is azt sugallja, hogy a feladat előfeltétele gyengébb (azaz az általa kijelölt állapothalmaz) lehet, mint a program előfeltétele. + +Foglaljuk most össze, hogy melyek a specifikáció részei! Ezek az eddigiek, valamint a programra vonatkozó további megkötések lesznek. + +\begin{enumerate} + \item A feladat specifikálása + \begin{itemize} + \item a feladat szövege, + \item a bemenő és a kimenő adatok elnevezése, értékhalmazának leírása, + \item a feladat szövegében használt fogalmak definíciói (a fogalmak fölhasználásával), + \item a bemenő adatokra felírt előfeltétel (a fogalmak fölhasználásával), + \item a kimenő adatokra felírt utófeltétel. + \end{itemize} + \item A program specifikálása + \begin{itemize} + \item a bemenő és a kimenő adatok elnevezése, értékhalmazának leírása, + \item (a feladat elő-, illetve utófeltételétől esetleg különböző) program elő- és utófeltétel, + \item a feladat megfogalmazásában használt fogalmak definíciói. + \end{itemize} +\end{enumerate} + +\noindent Ezek az absztrakt specifikáció elemei. Az alábbiak másodlagos, mondhatjuk: technikai specifikáció részei: + +\begin{itemize} + \item a program környezetének leírása (számítógép, memória- és perifériaigény, programozási nyelv, szükséges fájlok stb.), + \item a programmal szembeni egyéb követelmények (minőség, hatékonyság, hordozhatóság stb.). +\end{itemize} + +\noindent A technikai specifikáció nélküli leírást a program szűkebb specifikációjának nevezik.\\ + +\noindent Progos specifikáció:\\\\ +$A=(N : \mathbb{N}, A: \mathbb{N}^{1..N})$\\ +$Ef=(\forall i \in {1..N} : A_{i}>0)$\\ +$Uf=(Ef \land \forall i \in {1..N} : A_{MAX}>=A_{i} \land \forall j \in {1..MAX-1} : A_{i})$ helyett pl. $(\mathbb{Z},>)$ vagy $(\mathbb{Z},<)$ + \item $(H,+)$ helyett pl. $(\mathbb{Z},+)$ vagy $(\mathbb{R},*)$ + \end{itemize} + \item a változók átnevezése + \end{itemize} + \item A különbségek figyelembe vételével a tétel algoritmusából elkészítjük a konkrét feladatot megoldó algoritmust. +\end{enumerate} + +\section{Felsoroló, a felsoroló típus specifikációja} + +A gyűjtemény (tároló, kollekció, iterált) egy olyan adat +(objektum), amely valamilyen elemek tárolására alkalmas. +\begin{itemize} + \item Ilyenek az összetett szerkezetű, de különösen az iterált szerkezetű + típusok értékei: halmaz, sorozat (verem, sor, fájl), fa, gráf + + \item De vannak úgynevezett virtuális gyűjtemények is: pl. egész számok + egy intervallumának elemei, vagy egy természetes szám prím-osztói +\end{itemize} + +\noindent Egy gyűjtemény feldolgozásán a benne levő elemek +feldolgozását értjük. +\begin{itemize} + \item Keressük a halmaz legnagyobb elemét! + \item Hány negatív szám van egy számsorozatban? + \item Válogassuk ki egy fa leveleiben elhelyezett értékeket! + \item Járjuk be az [m .. n] intervallum minden második elemét visszafelé! + \item Adjuk össze az n természetes szám prím-osztóit! +\end{itemize} + +\noindent A feldolgozni kívánt elemek felsorolását (bejárását) az alábbi +műveletekkel szabványosítjuk: +\begin{itemize} + \item First() : Rááll a felsorolás első elemére, azaz elkezdi a felsorolást + \item Next() : Rááll az elkezdett felsorolás soron következő elemére + \item End() : Mutatja, ha a felsorolás végére értünk + \item Current() : Visszaadja a felsorolás aktuális elemét +\end{itemize} + +Egy felsorolásnak különböző állapotai vannak (indulásra kész, +folyamatban van, befejeződött), és a műveletek csak bizonyos +állapotokban értelmezhetők (máshol a hatásuk nem definiált). +A feldolgozó algoritmus garantálja, hogy a felsoroló műveletek mindig +megfelelő állapotban kerüljenek végrehajtásra. + +\begin{figure}[H] + \centering + \includegraphics[width=0.4\linewidth]{img/felsorolas_stuki} + \caption{A felsorolás algoritmusa} + \label{fig:felsorolas_stuki} +\end{figure} + +A felsorolást sohasem a felsorolni kívánt gyűjtemény, hanem +egy külön felsoroló objektum végzi. + +\begin{figure}[H] + \centering + \includegraphics[width=0.7\linewidth]{img/felsorolo_speci} + \caption{A felsoroló objektum és típusa} + \label{fig:felsorolas_stuki} +\end{figure} + +\section{Felsorolóra megfogalmazott programozási tételek} + +\includepdf[pages={1-2}]{progtetel_felsorolo.pdf} + +\section{Nevezetes gyűjtemények felsorolói} + +\subsection{Intervallum} +\begin{figure}[H] + \centering + \includegraphics[width=0.7\linewidth]{img/felsorolo_intervallum} + \caption{Intervallum felsorolója} + \label{fig:felsorolo_intervallum} +\end{figure} + +\subsection{Tömb} +Itt két különböző tömbtípus felsorolóját mutatjuk be: az egydimenziós (vektor) és a kétdimenziós tömbét (mátrix). + +\begin{figure}[H] + \centering + \includegraphics[width=0.7\linewidth]{img/felsorolo_vektor} + \caption{Vektor felsorolója} + \label{fig:felsorolo_vektor} +\end{figure} + +\begin{figure}[H] + \centering + \includegraphics[width=0.7\linewidth]{img/felsorolo_matrix} + \caption{Mátrix sorfolytonos felsorolója} + \label{fig:felsorolo_matrix} +\end{figure} + +Megjegyzés: a felsorolás történhet másképpen is, például vektor esetén végezhetjük a felsorolást visszafelé, a tömb végétől kezdve, vagy mátrixnál alkalmazhatunk pl. oszlopfolytonos bejárást. + +\subsection{Sorozat} +\begin{figure}[H] + \centering + \includegraphics[width=0.7\linewidth]{img/felsorolo_sorozat} + \caption{Sorozat felsorolója} + \label{fig:felsorolo_sorozat} +\end{figure} + +\subsection{Halmaz} +\begin{figure}[H] + \centering + \includegraphics[width=0.7\linewidth]{img/felsorolo_halmaz} + \caption{Halmaz felsorolója} + \label{fig:felsorolo_halmaz} +\end{figure} + +\subsection{Szekvenciális inputfájl} +\begin{figure}[H] + \centering + \includegraphics[width=0.7\linewidth]{img/felsorolo_seqin} + \caption{Szekvenciális inputfájl felsorolója} + \label{fig:felsorolo_seqin} +\end{figure} + +\end{document} \ No newline at end of file diff --git a/7.Programozás/img/adattipus.png b/7. Programozás/img/adattipus.png similarity index 100% rename from 7.Programozás/img/adattipus.png rename to 7. Programozás/img/adattipus.png diff --git a/7.Programozás/img/adattipus_pelda.png b/7. Programozás/img/adattipus_pelda.png similarity index 100% rename from 7.Programozás/img/adattipus_pelda.png rename to 7. Programozás/img/adattipus_pelda.png diff --git a/7.Programozás/img/felsorolas_stuki.png b/7. Programozás/img/felsorolas_stuki.png similarity index 100% rename from 7.Programozás/img/felsorolas_stuki.png rename to 7. Programozás/img/felsorolas_stuki.png diff --git a/7.Programozás/img/felsorolo_halmaz.png b/7. Programozás/img/felsorolo_halmaz.png similarity index 100% rename from 7.Programozás/img/felsorolo_halmaz.png rename to 7. Programozás/img/felsorolo_halmaz.png diff --git a/7.Programozás/img/felsorolo_intervallum.png b/7. Programozás/img/felsorolo_intervallum.png similarity index 100% rename from 7.Programozás/img/felsorolo_intervallum.png rename to 7. Programozás/img/felsorolo_intervallum.png diff --git a/7.Programozás/img/felsorolo_matrix.png b/7. Programozás/img/felsorolo_matrix.png similarity index 100% rename from 7.Programozás/img/felsorolo_matrix.png rename to 7. Programozás/img/felsorolo_matrix.png diff --git a/7.Programozás/img/felsorolo_seqin.png b/7. Programozás/img/felsorolo_seqin.png similarity index 100% rename from 7.Programozás/img/felsorolo_seqin.png rename to 7. Programozás/img/felsorolo_seqin.png diff --git a/7.Programozás/img/felsorolo_sorozat.png b/7. Programozás/img/felsorolo_sorozat.png similarity index 100% rename from 7.Programozás/img/felsorolo_sorozat.png rename to 7. Programozás/img/felsorolo_sorozat.png diff --git a/7.Programozás/img/felsorolo_speci.png b/7. Programozás/img/felsorolo_speci.png similarity index 100% rename from 7.Programozás/img/felsorolo_speci.png rename to 7. Programozás/img/felsorolo_speci.png diff --git a/7.Programozás/img/felsorolo_vektor.png b/7. Programozás/img/felsorolo_vektor.png similarity index 100% rename from 7.Programozás/img/felsorolo_vektor.png rename to 7. Programozás/img/felsorolo_vektor.png diff --git a/7.Programozás/img/stuki_alapszerk1.png b/7. Programozás/img/stuki_alapszerk1.png similarity index 100% rename from 7.Programozás/img/stuki_alapszerk1.png rename to 7. Programozás/img/stuki_alapszerk1.png diff --git a/7.Programozás/img/stuki_alapszerk2.png b/7. Programozás/img/stuki_alapszerk2.png similarity index 100% rename from 7.Programozás/img/stuki_alapszerk2.png rename to 7. Programozás/img/stuki_alapszerk2.png diff --git a/7.Programozás/img/stuki_pelda.png b/7. Programozás/img/stuki_pelda.png similarity index 100% rename from 7.Programozás/img/stuki_pelda.png rename to 7. Programozás/img/stuki_pelda.png diff --git a/7.Programozás/progtetel_felsorolo.pdf b/7. Programozás/progtetel_felsorolo.pdf similarity index 100% rename from 7.Programozás/progtetel_felsorolo.pdf rename to 7. Programozás/progtetel_felsorolo.pdf diff --git a/8. Objektumelvű modellezés/8. Objektumelvű modellezés.pdf b/8. Objektumelvű modellezés/8. Objektumelvű modellezés.pdf new file mode 100644 index 0000000..2c4add7 Binary files /dev/null and b/8. Objektumelvű modellezés/8. Objektumelvű modellezés.pdf differ diff --git a/8. Objektumelvű modellezés/8. Objektumelvű modellezés.tex b/8. Objektumelvű modellezés/8. Objektumelvű modellezés.tex new file mode 100644 index 0000000..85f911a --- /dev/null +++ b/8. Objektumelvű modellezés/8. Objektumelvű modellezés.tex @@ -0,0 +1,404 @@ +\documentclass[margin=0px]{article} + +\usepackage{listings} +\usepackage[utf8]{inputenc} +\usepackage{graphicx} +\usepackage{float} +\usepackage[a4paper, margin=0.7in]{geometry} +\usepackage{amsthm} +\usepackage{fancyhdr} +\usepackage{setspace} + +\onehalfspacing + +\renewcommand{\figurename}{ábra} +\newenvironment{tetel}[1]{\paragraph{#1 \\}}{} + +\pagestyle{fancy} +\lhead{\it{PTI BSc Záróvizsga tételek}} +\rhead{8. Objektumelvű modellezés} + +\title{\textbf{{\Large ELTE IK - Programtervező Informatikus BSc} \vspace{0.2cm} \\ {\huge Záróvizsga tételek}} \vspace{0.3cm} \\ 8. Objektumelvű modellezés} +\author{} +\date{} + +\begin{document} +\maketitle + +\begin{tetel}{Objektumelvű modellezés} + Az objektumelvű modellezés nézetrendszerei: statikus modell (osztálydiagram, objektumdiagram, csomag diagram, komponens diagram); dinamikus modell (állapotgép diagram, szekvencia diagram, kommunikációs diagram, használati eset diagram). +\end{tetel} + +\section{Az objektumelvű modellezés nézetrendszerei} + +\textbf{Objektumelvű programozás} = adatabsztrakció + absztrakt adattípus + típusöröklődés +\begin{itemize} + \item Absztrakció + + Programozás adott szintjén a megoldás szempontjából + lényegtelen részletek elhanyagolása. + + \item Adattípus + + Az adattípus egy $ (A,F) $ rendezett pár, ahol $ A $ az adatok halmaza $ F $ pedig a műveletek véges halmaza. ($ \forall f \in F : f:A^n \rightarrow A $) Létezik egyszerű és összetett adattípus.\\ + \textbf{Típusosztály:} A típus komplex leírása, mely az adott adattípus \underline{absztrakt} (PAR + EXP) és \underline{konkrét} (IMP + BODY) leírását szolgálja. Tehát:\\\\ + Típusosztály = (PAR, EXP, IMP, BODY), ahol:\\ + PAR = \textless paraméterek tulajdonságai \textgreater\\ + EXP = \textless típusobjektumok halmaza és műveltei neve, szintaktikája, szemantikája \textgreater\\ + IMP = \textless más osztályból átvett szolgáltatások \textgreater\\ + BODY = \textless típusosztály ábrázolása, megvalósítása \textgreater\\ + + \item Típusöröklődés + + A típusöröklődés két fő formája: \textit{specializáció} és \textit{újrafelhasználás} + \begin{enumerate} + \item A subclass átveszi az absztakt tulajdonságokat és azt az export részben használja fel + \item Típushalmaz, paraméterhalmazok, műveletek nevei átdefiniálódhatnak. + \item subclass típushalmaza = superclass típushalmaza + \end{enumerate} + + A specializáció következményei: + \begin{itemize} + \item polimorfizmus + + Minden változónak két típusa van: \textit{statikus} (deklaráció során kapott) és \textit{dinamikus} (deklaráció pillanatában megegyezik a statikussal, de később megváltozhat, ha egy superclass példánynak adunk értékül egy subclass példányt) + \item dinamikus kötés + + A dinamikus típusnak megfelelő kiszámítási szabály hozzárendelése a függvényhez attribútumhoz, a végrehajtás pillanatában + \end{itemize} + \paragraph{Nézetrendszerek} + \begin{itemize} + \item használati szempont + + Kinek nyújt a rendszer szolgáltatást? (Személyek vagy más rendszerek, programok) + + \item Szerkezetei strukturális, statikus szempont + + Milyen egységek vannak, ezeknek mi a feladata, és hogyan kapcsolódnak egymáshoz? + + \item Dinamikus szempont + + Az egyes részegységek hogyan viselkednek, milyen állapotokat vesznek fel, azokat milyen események hatására váltják? Milyen az egységek között együttműködés mechanizmusa? Időben hogyan játszódnak le közöttük az üzentek? + + \item Implementációs szempont + + Milyen szoftverkomponensek, és azok között milyen kapcsolatok vannak? + + \item Környezeti szempont + + A rendszer milyen hardver és szoftver erőforrást igényel a megoldás során? + \end{itemize} +\end{itemize} +\section{Statikus modell (osztálydiagram, objektumdiagram, csomag diagram, komponens diagram)} +\subsection{Osztáldiagram} +A megoldás szerkezetét leíró összefüggő gráf, melynek csomópontjaihoz az osztályokat, éleihez pedig az osztályok közötti relációkat (öröklődés, asszociáció, aggregáció, kompozíció) rendeljük. + +\noindent +A rendszerhez csak egy osztálydiagram tartozik. + +\begin{description} + \item[Osztályok] \hfill \\ + + Egy osztály a következőképp néz ki: + \begin{figure}[H] + \centering + \includegraphics[width=0.4\textwidth]{img/osztaly.png} + \caption{Osztály} + \end{figure} + + Az osztályt leíró téglalap 3 részre van osztva. + \begin{itemize} + \item Az első részbe az osztály neve kerül. + + Ha az osztály absztrakt, a nevét dőlt betűvel írjuk. + + \item A második részbe az osztály attribútumai kerülnek. + + Az attribútum formátuma: \textit{Attribútumnév : Típus} + A statikusságot aláhúzással jelöljük. + Az attribútumok láthatóságát is fel lehet tüntetni: \textit{ publikus (+), privát (-), védett (\#)} + + \item A harmadik részbe az osztály metódusai kerülnek. + + A metódusok formátuma: \textit{Metódusnév(Paraméterlista):Visszatérési érték}, ahol a paraméterlista \textit{Paraméternév:Típus} fomrátumú paraméterekből áll. + Absztraktságot, statikusságot, és láthatóságot az előzőekben leírtakkal azonosan jelöljük. + \end{itemize} + \item[Osztályok közötti kapcsolatok:] \hfill \\ + + \begin{itemize} + \item öröklődés + + Két osztály közötti absztrakciós kapcsolatot jelöl + \begin{figure}[H] + \centering + \includegraphics[width=0.2\textwidth]{img/oroklodes.png} + \caption{Öröklődés} + \end{figure} + + \item asszociáció + + Ez a legáltalánosabb reláció két osztály között. Az asszociáció két osztály + közötti absztrakt reláció, amely kétirányú társítást fejez ki. A + reláció absztrakt volta azt jelenti, hogy a reláció konkretizálása osztályok + objektumainak összekapcsolásában valósul meg. + + Az asszociációnak lehet: + \begin{itemize} + \item Neve, azonosítója + \item Iránya + \item Multiplicitása + + Akár egy érték, akár intervallum. A * szimbólum kitüntett szerepet kap, jelentése: bármennyi, akár nulla is. (Pl: 3, 1..4, 5..*, *) + \item Szerepe + \item Navigálhatósága + + A társított osztályok közül csak az egyik ismeri a másikat. (Ha nem tüntetjük fel, kölcsönös elérhetőséget feltételezünk) + + \begin{figure}[H] + \centering + \includegraphics[width=0.5\textwidth]{img/asszociacio.png} + \caption{Asszociáció} + \end{figure} + \end{itemize} + \item aggregáció + + Az aggregáció egy speciális asszociáció, mely egész-rész kapcsolatot fejez ki. Azonban ha két osztály között aggregációs reláció áll fenn, a két osztály objektumai egymástól függetlenül is létezhetnek (Ezt un. laza tartalmazási relációnak nevezik) A relációt jellemzi ezen kívül a tranzitivitás, és a közös attribútumok illetve szolgáltatások. Különböző aggregátumoknak lehetnek közös komponenseik. + \begin{figure}[H] + \centering + \includegraphics[width=0.5\textwidth]{img/aggregacio.png} + \caption{Aggregáció} + \end{figure} + \item kompozíció + + A kompozíció egy speciális aggregáció, mely \textit{fizikai} tartalmazást jelöl. Nem jellemzi többé az objektumok független létezése, a két objektum egyszerre jön létre és szűnik meg. Tehát a tartalmazó objektumnak gondoskodnia kell a tartalmazott létrehozásáról és megszüntetéséről. Egy komponens legfeljebb egy tartalmazó \underline{objektumhoz} tartozhat. A kompozíciós kapcsolat és az attribútum jellegű kapcsolat két objektum között szemantikailag azonos. + \begin{figure}[H] + \centering + \includegraphics[width=0.4\textwidth]{img/kompozicio.png} + \caption{Kompozíció} + \end{figure} + \end{itemize} +\end{description} + +\subsection{Objektumdiagram} +Az objektumdiagram egyszeresen összefüggő gráf, amelynek csomópontjaihoz az objektumokat, éleihez pedig az objektumok közötti összekapcsolásokat rendeljük. + +A rendszerhez különböző időpillanatokban más-más objektumdiagram tartozhat. (Viszont mindegyiknek meg kell felelnie az osztálydiagramnak) + +\begin{description} + \item[Objektumok] \hfill \\ + Az objektumokat az osztályokhoz hasonlóan egy téglalap írja le. Egy ilyen téglalapnak két része van. Az első részben az objektum neve (opcionális) és típusa található a következő formátumban: \textit{Objektumnév : Típus}, melyet aláhúzással tarkítunk. A második részbe az objektum attribútumai és azok értékei kerülhetnek, a következő formátumban: \textit{Attribútumnév=érték}. + \begin{figure}[H] + \centering + \includegraphics[width=0.2\textwidth]{img/objektum.png} + \caption{Objektum} + \end{figure} + \item[Objektumok közötti kapcsolatok] \hfill \\ + Az objektumokat összekötő relációk az osztálydiagramon lévőkkel megegyezőek (Öröklődésnek ezen a szinten nincs értelme): + \begin{itemize} + \item asszociáció + \begin{figure}[H] + \centering + \includegraphics[width=0.5\textwidth]{img/asszociacio2.png} + \caption{Asszociáció} + \end{figure} + \item aggregáció + \begin{figure}[H] + \centering + \includegraphics[width=0.7\textwidth]{img/aggregacio2.png} + \caption{Aggregáció} + \end{figure} + \item kompozíció + \begin{figure}[H] + \centering + \includegraphics[width=0.5\textwidth]{img/kompozicio2.png} + \caption{Aggregáció} + \end{figure} + \end{itemize} +\end{description} + +\subsection{Csomag diagram} +A csomag diagram alapvetően más modell elemek csoportosítására használható, és mint ilyen, szintén minden fejlesztési fázisban használatos. A használati eset modell elkészítése során a használati eset leltár esetén már említésre került, ebben a fejezetben összefoglaljuk a részletes szabályokat. A csomag jele az UML-ben egy ``füles'' téglalap. A fül felirata lehet a csomag neve, de írható a téglalapba is. A csomagnév fölött sztereotípiát adhatunk meg, alatta megszorítást. A csomag tartalma lehet bármilyen szövegesen vagy diagrammal megadott modell elem, illetve azok halmaza. A korábban már említett használati eset leltár például használati eseteket tartalmazó csomagokból áll. A csomagok újabb csomagot is tartalmazhatnak. Egy modell elem csak egy csomaghoz tartozhat. Így a csomagok fa struktúrájú hierarchiát alkotnak, hasonlóan, mint a filerendszerek elemei, vagy a Java csomagok. + +A <> sztereotípiával jelzett csomag a legfelső szintű, az egész alkalmazást jelképező csomag. A csomagok közötti függőségek szaggatott, nyitott hegyű nyíllal ábrázolhatjuk. A kapcsolat jellegét sztereotípiával pontosíthatjuk. Az UML csomag egyben egy névteret is képvisel, ezért egy csomagon belül nem lehet két azonos nevű modell elem. Ha egy másik csomagban levő modell elemre akarunk hivatkozni, azt a minősített nevével tehetjük meg. A minősített név tartalmazza azon csomagok neveit, amelyeken keresztül eljuthatunk az adott modell elemig. A csomagneveket a :: választja el egymástól. + +A csomag elemeihez public(+) és private (-) láthatóságot is rendelhetünk, hasonlóan az osztályok elemeihez. +A minősített névvel való hivatkozás nehézkes lehet a hosszúsága miatt, és minden ilyen hivatkozásra hatással lehet a csomagok átszervezése. Ezért helyette egyszerűbb és célszerűbb a csomagok közötti hivatkozásokat a függőséget jelölő (szaggatott vonallal rajzolt) nyíllal és sztereotípiákkal jelölni (importálás). Az importált elem az importáló csomag számára látható lesz. A használható sztereotípiák: + +<>: nyilvános import, az importáló csomag tovább exportálhatja + +<>: privát import, csak az importáló csomag láthatja. + +Jelölése: +\begin{itemize} + \item Az importáló csomagtól közvetlenül az importált elemre mutató szaggatott nyíl + \item Az importáló csomagtól az importált elemet tartalmazó csomagra mutató nyíl, a sztereotípia után írva az importálandó elem neve + \item A két csomag között rajzolt, elemnév nélküli nyíl a teljes csomag valamennyi elemének importálását jelenti. +\end{itemize} + +\begin{figure}[H] + \centering + \includegraphics[width=0.5\textwidth]{img/csomag_diagram.jpg} + \caption{Csomag diagram: elem importálása} +\end{figure} + +\subsection{Komponens diagram} +A komponens az UML-ben egy olyan univerzális egység, amely valamilyen szolgáltatás halmazt képvisel, azokat egy egységbe zárja. A szolgáltatásokat más komponensek interfészeken keresztül érhetik el. Egy komponens kicserélhető egy másikkal, ha ugyanolyan interfésszel rendelkezik, és ugyanazokat a szolgáltatásokat nyújtja. + +Egy komponens tartalmazhat más komponenseket. + +A komponensek fogalma jól használható a fejlesztés minden fázisában. Így jelenthet egy implementációs értelemben vett komponenst (például egy Enterprise JavaBean-t), de akár egy komplett alrendszert is (például könyvelés). + +A komponens jele egy téglalap a <> sztereotípiával, vagy egy ikonnal megjelölve. A komponens a külvilággal csatlakozókon (port) keresztül teremt kapcsolatot. Minden csatlakozóhoz egy vagy több interfész kapcsolható. A külvilág felé szolgáltatásokat nyújtó interfészt (nyújtott interfész) egy körrel, a komponens által másoktól igényeltet (megkövetelt interfész) egy félkörrel jelöljük. A komponensek közötti kapcsolatokat az interfészek összeillesztésével ábrázolhatjuk. Egy nyújtott interfész csak egy megkövetelt interfésszel állhat kapcsolatban. (Ezt jól szemléltetik a jelölések is.) + +A komponens diagram jelöléseit szemlélteti az alábbi ábra, amely az esettanulmány komponens diagramjának egy részlete. + +\begin{figure}[H] + \centering + \includegraphics[width=0.5\textwidth]{img/komponens_diagram.jpg} + \caption{Komponens diagram} +\end{figure} + + +\section{Dinamikus modell (állapotdiagram, szekvenciadiagram,\\ együttműködési diagram, tevékenységdiagram)} + +\subsection{Állapotdiagram} +Az állapotdiagram egy összefüggő irányított gráf, amelynek csomópontjaihoz az állapotokat rendeljük, éleihez pedig az eseményeket. (Két csúcs között több állapotátmenetet is jelölhetünk, hiszen több esemény hatására is létrejöhet) +\begin{description} + \item[Állapot] \hfill \\ + Az objektum állapotát az attribútumok konkrét értékeinek n-esével jellemezzük. + + Az állapotnak van azonosítója, mely legtöbbször az állapot neve (de lehet maga az invariáns, vagy az attribútumok konkrét értéke). Az állapotot esemény hozza létre és szünteti meg. Az állapot mindaddig fennmarad, míg az attribútumok kielégítik az állapotot leíró invariánst. Az állapotot egy lekerekített téglalappal jelöljük, melyben az azonosítót tüntetjük fel. + + Speciális (rendszeren kívüli) állapotok: Kezdőállapot, Végállapot + \item[Esemény] \hfill \\ + Eseménynek nevezzük azt a tevékenységet, történést, amely valamely objektum állapotát megváltoztatja. + + Az esemény lehet paraméteres vagy paraméter nélküli, és lehet előfeltétele. Az események között sorrendiség áll fent, így egy esemény lehet megelőző eseménye. Egy eseményt a következőképp írhatunk le:\\ + \textless esemény \textgreater (\textless paraméterek\textgreater)[\textless feltétel\textgreater]/\textless megelőző esemény\textgreater + + Az eseményeket az állapotok közötti állapotátmenetekre írjuk. + \begin{figure}[H] + \centering + \includegraphics[width=0.5\textwidth]{img/plane.png} + \caption{Repülőgép állapotgépe} + \end{figure} +\end{description} +\subsection{Szekvenciadiagram} +A szekvencia diagram az objektumok közötti üzenetváltások időbeli menetét +szemlélteti. +\begin{description} + \item[Osztályszerep] \hfill \\ + Az osztály szerepét olyan egy vagy több objektum testesíti meg, melyek az üzenetküldés szempontjából konform módon viselkednek. + \item[Osztályszerep életvonal] \hfill \\ + Az életvonal az osztályszerep időben való létezését jelenti. + \begin{figure}[H] + \centering + \includegraphics[width=0.3\textwidth]{img/eletvonal.png} + \caption{Életvonal} + \end{figure} + \item[Aktivációs életvonal] \hfill \\ + Az aktivációs életvonal azt az állapotot jelenti, amikor az osztályszerep megtestesítői műveleteket hajtanak végre, vagy más objektumok vezérlése alatt állnak. + \begin{figure}[H] + \centering + \includegraphics[width=0.3\textwidth]{img/aktivacios_eletvonal.png} + \caption{Aktivációs életvonal} + \end{figure} + \item[Üzenet] \hfill \\ + Az üzenet az objektumok közötti információátadás formája. Az üzenet küldésének az a célja, hogy az objektum működésbe hozza a másik objektumot. Az üzenet azok között az objektumok között jöhet létre, amelyek az objektumdiagramban kapcsolatban állnak. Az üzenetnek van azonosítója (neve, szövege), lehet paramétere, sorszáma. + +\end{description} +\subsection{Együttműködési diagram} +Az együttműködési diagram azt hivatott bemutatni, hogy miként működnek együtt az osztályok objektumai, milyen üzenetek cseréje révén valósul meg ez az együttműködés. +(Csak azok az objektumok relevánsak, amelyek osztályait az osztálydiagramban asszociációs kapcsolat köt össze. A diagram mutatja ezt az összekapcsolást és az ehhez tartozó +üzenetváltásokat, ezért az együttműködési diagram az objektumdiagram bizonyos értelemben vett kiterjesztésének tekinthető.) + +Az üzenet küldését egy nyíl mutatja, amely az asszociáció mellett kap helyet és a címzett irányába mutat. Az üzenet azonosítója a nyíl mentén helyezkedik el. Az üzenetnek lehet argumentuma és eredménye. Ezeket egy kis körből induló nyíl mellett helyezzük el, ahol a nyíl az információ áramlásának irányát mutatja. + + +\subsection{Tevékenységdiagram} +A tevékenységdiagram (aktivációs diagram) a probléma megoldásának lépéseit szemlélteti, a párhuzamosan zajló vezérlési folyamatokkal együtt. + +Ha egy tevékenységet +egy másik tevékenység követ közvetlenül, akkor a két tevékenységet +nyíllal kötjük össze. Ha adatot (objektumot) ad át egy tevékenység +egy másik tevékenységnek, akkor a küldő tevékenységből szaggatott +nyíl vezet az objektumot reprezentáló téglalaphoz, és a téglalaptól +szaggatott nyíl mutat a fogadó tevékenységre. A téglalapban szögletes +zárójelek között megadhatjuk az objektum állapotát, státuszát is. +\begin{figure}[H] + \centering + \includegraphics[width=0.3\textwidth]{img/tevekenyseg.png} + \caption{Objektum átadás} +\end{figure} + +Lehetőség van arra, hogy bizonyos feltételek teljesülése esetén eltérő +tevékenységeket hajtsunk végre, illetve tevékenységek végrehajtását +feltételekhez kössük. Ekkor egy rombuszt kell elhelyeznünk a diagramban, +amelyből kivezető nyilakra írjuk a feltételeket. + +\begin{figure}[H] + \centering + \includegraphics[width=0.4\textwidth]{img/tevekenyseg2.png} + \caption{Feltétel ábrázolása} +\end{figure} + +\subsection{Kommunikációs diagram} + +A kommunikációs diagram, a szekvencia diagramhoz hasonlóan, objektumok közötti üzenetváltásokat képes ábrázolni, azonban ebben az esetben nem az üzenetváltások időbeliségére helyezzük a hangsúlyt, hanem az üzenetváltásokban részvevő objektumok közötti kapcsolatokra. A szekvencia diagramon az objektumok kapcsolata csak közvetve jelenik meg, azáltal, hogy mely elemek között van interakció. A kommunikációs diagramon az együttműködő objektumok az osztálydiagramoknál már megismert, asszociációkat jelző vonalakkal (nyilakkal) vannak összekötve. Az üzenetek időbeli sorrendjét az üzeneteket számozása jelzi. + +A kommunikációs diagramon is szerepelhet aktor, mint az üzenet forrása vagy címzettje. + +Jelölni lehet, ha egy objektum aktív (önállóan képes üzenetet küldeni), illetve ha egy üzenet nem egy objektumhoz, hanem azonos osztályhoz tartozó objektumok egy halmazához irányul (multiobjektum). + +Példaként rajzoljuk meg egy bank automatából való készpénzfelvétel kommunikációs diagramját. Feltételezzük, hogy az ügyfél a kártya beolvasásával és a PIN lód megadásával már azonosította magát, és a lehetséges funkciók közül kiválasztotta a készpénzfelvételt. + +\begin{figure}[H] + \centering + \includegraphics[width=0.4\textwidth]{img/kommunikacios_diagram.jpg} + \caption{Kommunikációs diagram} +\end{figure} + +\section{Használati esetek diagramja} +A használati esetek diagramja a felhasználók szempontjából kívánja +szemléltetni azt, hogy a rendszer miként működik, függetlenül attól, +hogy a szolgáltatásait hogyan valósítja meg. + +\noindent +A diagram részei: +\begin{itemize} + \item használati esetek + \item felhasználók + \item felhasználási relációk +\end{itemize} + +A használati esetek a rendszer funkcióinak összefoglalásai, szolgáltatási +egységek. Ez az egység az akcióknak egy olyan sorozata, amelyekkel +a rendszer a felhasználók egy csoportjával működik együtt. + +A használati esetet egy ovális alakzattal jelöljük. A használati eseteket téglalapba foglaljuk, ez jelzi a rendszer határait. + +A felhasználók az adott rendszeren kívüli egységek, más programrendszerek, +alrendszerek, osztályok, illetve személyek lehetnek. Ezek +aktor szerepet töltenek be. A diagramon egy pálcikaember figurával jelöljük. + +A felhasználási relációk kapcsolják össze a használati eseteket a +felhasználókkal. A relációk egymással is kapcsolatban állhatnak, amit +a diagramban fel lehet tüntetni. A lehetséges relációk a következők: +\begin{itemize} + \item asszociáció \\ + Egy felhasználó és egy használati eset közötti kapcsolatot jelez. (Egyszerű vonal) + \item általánosítás \\ + Az egyik használati eset a másik általánosabb formája. (Egyszerű vonal, végén fehér háromszöggel) + \item kiterjesztés \\ + Az egyik használati eset a másikat terjeszti ki. Ennek + során viselkedéseket illeszt be megadott beszúrási pontoknál. (Szaggatott nyíl $\ll$extend$\gg$ felirattal) + \item tartalmazás \\ + Az egyik használati eset tartalmazza a másik viselkedését (Szaggatott nyíl $\ll$include$\gg$ felirattal) +\end{itemize} + +\begin{figure}[H] + \centering + \includegraphics[width=0.7\textwidth]{img/hasznalatieset.png} + \caption{Használati esetek diagramja} +\end{figure} +\end{document} \ No newline at end of file diff --git a/8.Programfejlesztési modellek/img/Hasznalatieset.png b/8. Objektumelvű modellezés/img/Hasznalatieset.png similarity index 100% rename from 8.Programfejlesztési modellek/img/Hasznalatieset.png rename to 8. Objektumelvű modellezés/img/Hasznalatieset.png diff --git a/8.Programfejlesztési modellek/img/Kompozicio2.png b/8. Objektumelvű modellezés/img/Kompozicio2.png similarity index 100% rename from 8.Programfejlesztési modellek/img/Kompozicio2.png rename to 8. Objektumelvű modellezés/img/Kompozicio2.png diff --git a/8.Programfejlesztési modellek/img/Objektum.png b/8. Objektumelvű modellezés/img/Objektum.png similarity index 100% rename from 8.Programfejlesztési modellek/img/Objektum.png rename to 8. Objektumelvű modellezés/img/Objektum.png diff --git a/8.Programfejlesztési modellek/img/Plane.png b/8. Objektumelvű modellezés/img/Plane.png similarity index 100% rename from 8.Programfejlesztési modellek/img/Plane.png rename to 8. Objektumelvű modellezés/img/Plane.png diff --git a/8.Programfejlesztési modellek/img/Tevekenyseg2.png b/8. Objektumelvű modellezés/img/Tevekenyseg2.png similarity index 100% rename from 8.Programfejlesztési modellek/img/Tevekenyseg2.png rename to 8. Objektumelvű modellezés/img/Tevekenyseg2.png diff --git a/8.Programfejlesztési modellek/img/aggregacio.png b/8. Objektumelvű modellezés/img/aggregacio.png similarity index 100% rename from 8.Programfejlesztési modellek/img/aggregacio.png rename to 8. Objektumelvű modellezés/img/aggregacio.png diff --git a/8.Programfejlesztési modellek/img/aggregacio2.png b/8. Objektumelvű modellezés/img/aggregacio2.png similarity index 100% rename from 8.Programfejlesztési modellek/img/aggregacio2.png rename to 8. Objektumelvű modellezés/img/aggregacio2.png diff --git a/8.Programfejlesztési modellek/img/aktivacios_eletvonal.png b/8. Objektumelvű modellezés/img/aktivacios_eletvonal.png similarity index 100% rename from 8.Programfejlesztési modellek/img/aktivacios_eletvonal.png rename to 8. Objektumelvű modellezés/img/aktivacios_eletvonal.png diff --git a/8.Programfejlesztési modellek/img/asszociacio.png b/8. Objektumelvű modellezés/img/asszociacio.png similarity index 100% rename from 8.Programfejlesztési modellek/img/asszociacio.png rename to 8. Objektumelvű modellezés/img/asszociacio.png diff --git a/8.Programfejlesztési modellek/img/asszociacio2.png b/8. Objektumelvű modellezés/img/asszociacio2.png similarity index 100% rename from 8.Programfejlesztési modellek/img/asszociacio2.png rename to 8. Objektumelvű modellezés/img/asszociacio2.png diff --git a/8. Objektumelvű modellezés/img/csomag_diagram.jpg b/8. Objektumelvű modellezés/img/csomag_diagram.jpg new file mode 100644 index 0000000..3203ccc Binary files /dev/null and b/8. Objektumelvű modellezés/img/csomag_diagram.jpg differ diff --git a/8.Programfejlesztési modellek/img/eletvonal.png b/8. Objektumelvű modellezés/img/eletvonal.png similarity index 100% rename from 8.Programfejlesztési modellek/img/eletvonal.png rename to 8. Objektumelvű modellezés/img/eletvonal.png diff --git a/8. Objektumelvű modellezés/img/kommunikacios_diagram.jpg b/8. Objektumelvű modellezés/img/kommunikacios_diagram.jpg new file mode 100644 index 0000000..3eecef1 Binary files /dev/null and b/8. Objektumelvű modellezés/img/kommunikacios_diagram.jpg differ diff --git a/8. Objektumelvű modellezés/img/komponens_diagram.jpg b/8. Objektumelvű modellezés/img/komponens_diagram.jpg new file mode 100644 index 0000000..c8417f2 Binary files /dev/null and b/8. Objektumelvű modellezés/img/komponens_diagram.jpg differ diff --git a/8.Programfejlesztési modellek/img/kompozicio.png b/8. Objektumelvű modellezés/img/kompozicio.png similarity index 100% rename from 8.Programfejlesztési modellek/img/kompozicio.png rename to 8. Objektumelvű modellezés/img/kompozicio.png diff --git a/8.Programfejlesztési modellek/img/oroklodes.png b/8. Objektumelvű modellezés/img/oroklodes.png similarity index 100% rename from 8.Programfejlesztési modellek/img/oroklodes.png rename to 8. Objektumelvű modellezés/img/oroklodes.png diff --git a/8.Programfejlesztési modellek/img/osztaly.png b/8. Objektumelvű modellezés/img/osztaly.png similarity index 100% rename from 8.Programfejlesztési modellek/img/osztaly.png rename to 8. Objektumelvű modellezés/img/osztaly.png diff --git a/8.Programfejlesztési modellek/img/tevekenyseg.png b/8. Objektumelvű modellezés/img/tevekenyseg.png similarity index 100% rename from 8.Programfejlesztési modellek/img/tevekenyseg.png rename to 8. Objektumelvű modellezés/img/tevekenyseg.png diff --git a/9. Objektumelvű tervezés/9. Objektumelvű tervezés.pdf b/9. Objektumelvű tervezés/9. Objektumelvű tervezés.pdf new file mode 100644 index 0000000..f4b0145 Binary files /dev/null and b/9. Objektumelvű tervezés/9. Objektumelvű tervezés.pdf differ diff --git a/9. Objektumelvű tervezés/9. Objektumelvű tervezés.tex b/9. Objektumelvű tervezés/9. Objektumelvű tervezés.tex new file mode 100644 index 0000000..f65228c --- /dev/null +++ b/9. Objektumelvű tervezés/9. Objektumelvű tervezés.tex @@ -0,0 +1,509 @@ +\documentclass[margin=0px]{article} + +\usepackage{listings} +\usepackage[utf8]{inputenc} +\usepackage{graphicx} +\usepackage{float} +\usepackage[a4paper, margin=0.7in]{geometry} +\usepackage{amsthm} +\usepackage{fancyhdr} +\usepackage{setspace} + +\onehalfspacing + +\renewcommand{\figurename}{ábra} +\newenvironment{tetel}[1]{\paragraph{#1 \\}}{} + +\pagestyle{fancy} +\lhead{\it{PTI BSc Záróvizsga tételek}} +\rhead{9. Objektumelvű tervezés} + +\title{\textbf{{\Large ELTE IK - Programtervező Informatikus BSc} \vspace{0.2cm} \\ {\huge Záróvizsga tételek}} \vspace{0.3cm} \\ 9. Objektumelvű tervezés} +\author{} +\date{} + +\begin{document} +\maketitle + +\begin{tetel}{Objektumelvű tervezés} + Nagy rendszerek fejlesztési fázisai, fejlesztési módszerek. SOLID tervezési elvek. Architekturális minták (MV, MVC stb.). Tervezési minták szerepe, osztályozása (létrehozási, szerkezeti, viselkedési), és kategóriánként 2-2 nevezetes tervezési minta bemutatása. +\end{tetel} + +\section{Nagy rendszerek fejlesztési fázisai, kapcsolataik} + +\subsection{Fejlesztési fázisok} +\begin{enumerate} + \item A probléma megoldásának előzménye + + Egy probléma megoldása előtt meg kell vizsgálni a megvalósíthatóságát, és annak mikéntjét. Eredmény: \textit{Megvalósíthatósági tanulmány}, mely a következőkre válaszol: + \begin{itemize} + \item Erőforrások (hardver, szoftver, szakember) + \item Költségek + \item Határidő + \item Üzemeltetés + \end{itemize} + \item Követelmények leírása + + Rendszerint iteratív módon állítjuk elő, és a prototípust használjuk a finomításra (ábra \ref{fig:kovetelmenyleiras}). + + \begin{figure}[H] + \centering + \includegraphics[width=0.5\textwidth]{img/kovetelmenyleiras.png} + \caption{Követelményleírás elkészítésének folyamata} + \label{fig:kovetelmenyleiras} + \end{figure} + + Követelmények leírásának tartalma: + + \begin{itemize} + \item Probléma + \item Korlátozó tényezők (hardver, szoftver, stb.) + \item Elfogadható megoldás + \end{itemize} + + Követelmények leírásának fajtái: + + \begin{itemize} + \item Funkcionális követelmények + + A rendszer szolgáltatásainak, leképzéseinek leírása: + \begin{itemize} + \item Elindítás formája + \item Bemenő adatok (és azok megadásának formája) + \item Igénybevétel előfeltétele, korlátozások + \item Szolgáltatás kezdeményezésére a válasz, eredmények + \item Válasz megjelenési formája + \item Bemenő adatok és válasz közti reláció + \end{itemize} + \item Nem funkcionális követelmények + + A nem funkcionális követelményeket rendszerint három osztályba soroljuk: a termék követelményei, menedzselési követelmények, külső követelmények. Az osztályokat tovább lehet bontani (ábra \ref{fig:nemfunkckov}). + \begin{figure}[H] + \centering + \includegraphics[width=0.5\textwidth]{img/nemfunkckov.png} + \caption{Nem funkcionális követelmények osztályozása} + \label{fig:nemfunkckov} + \end{figure} + \end{itemize} + + \item Követelmények elemzése és prototípus + + A következőket kell megvizsgálni: + \begin{itemize} + \item Önmagában jó-e a követelmények leírása? + \begin{itemize} + \item Konzisztens (nincs ellentmondás) + \item Komplett (teljes) + \end{itemize} + \item Validáció vizsgálat + + (Megfelel-e a felhasználó által elképzelt problémának?) + + \item Megvalósíthatósági vizsgálat + + (A követelményeknek megfelelő megoldás megvalósítható-e?) + + \item Tesztelhetőségi vizsgálat + + (A követelmények úgy vannak-e megfogalmazva, hogy azok tesztelhetők?) + + \item Nyíltság kritériumainak vizsgálata. + + (A követelmények nem mondanak-e ellent a módosíthatóság, a továbbfejleszthetőség + követelményének?) + \end{itemize} + + A követelmények elemzésének egyik eszköze a prototípus-készítés. + A prototípus magas szintű programozási környezetben létrehozott, a + külső viselkedés szempontjából helyes megoldása a problémának. + \item Programspecifikáció + + A programspecifikáció a következő kérdésekre kell, hogy válaszoljon a + követelmények leírása alapján: + + \begin{itemize} + \item Mik a bemenő adatok? (Forma, jelentés, megjelenés.) + \item Mik az eredmények? (Forma, jelentés, megjelenés.) + \item Mi a reláció a bemenő adatok és az eredmény adatok között? + \end{itemize} + \item Tervezés + + A tervezés során a következő kérdésekre adjuk + meg a választ: + \begin{enumerate} + \item Statikus modell + \begin{itemize} + \item Rendszer szerkezete + \item Programegységek, azok feladata és kapcsolata + \end{itemize} + \item Dinamikus modell + \begin{itemize} + \item Hogyan oldja meg a rendszer a problémát? + \item Milyen egységek működnek együtt? + \item Milyen üzenetek játszódnak le? + \item Rendszer és egységek állapotai + \item Események (melyek hatására állapotváltás történik) + \end{itemize} + + \item Funkcionális modell + \begin{itemize} + \item Milyen adatáramlások révén valósulnak meg a szolgáltatások? + \item Milyen leképezések játszanak szerepet az adatáramlásokban? + \item Mik az ajánlások az implementáció számára? + \begin{itemize} + \item Implementációs stratégiára vonatkozó ajánlás. + \item Programozási nyelvre vonatkozó előírás, ajánlás. + \item Tesztelési stratégiára vonatkozó ajánlás. + \end{itemize} + \end{itemize} + \end{enumerate} + + A gyakorlatban két tervezési módszer terjedt el: + \textit{procedurális} és a \textit{objektumelvű} + + (\textit{procedurális}: megvalósítandó funkciókból, műveletekből indulunk ki, és ezek alapján bontjuk fel a rendszert kisebb összetevőkre, modulokra\\ + \textit{objektumelvű}: a rendszer funkciói helyett az + adatokat állítjuk a tervezés középpontjába. A rendszer által használt + adatok felelnek meg majd bizonyos értelemben az objektumoknak.) + + \item Implementáció + + Fontos szempontok: + \begin{itemize} + \item Reprezentáció (Adatok ábrázolása) + \item Események leképezések megvalósítása + + Algoritmusok és optimalizálások + \end{itemize} + + Az implementáció egyik alapvető kérdése az implementációs stílus. + A jó programozási stílus néhány fontos eleme: + \begin{itemize} + \item absztrakció különböző szintjeinek alkalmazása + \item öröklődési technika használata, absztrakciós szintek hierarchikus + rendszere + \item absztrakciós szintekre bontás osztályon belül (deklaráció + megvalósítás) + \item korlátolt láthatóság; + \item információ elrejtés (information hiding); + \item információ beburkolás (encapsulation). + \end{itemize} + + \item Verifikáció, validáció + + A rendszer eleget tesz-e a vele szemben támasztott elvárásoknak? + + Verifikáció: a specifikációszerinti helyesség igazolása + + Validáció: Minőségi előírások teljesítése (robosztusság hatékonyság, erőforrásigény) + + Ennek folyamata: tesztelés, melynek szakaszai: + \begin{itemize} + \item Egységteszt + \item Rendszerteszt + \end{itemize} + A tesztelésnek két módja lehet: + \begin{itemize} + \item fekete doboz - Csak a maguknak a hibáknak a felderítése + \item fehér doboz - Hibák helyének felderítése + \end{itemize} + + \item Rendszerkövetés és karbantartás (maintenance) + + Karbantartás: Üzemebe helyezés után szükségessé váló szoftver jellegű munkák [pl.: rejtett hibák kijavítása, adaptációs munkák (új harver-, szoftverkörnyezet), továbbfejlesztési munkák] + + Rendszerkövetés: a felhasználókkal való kapcsolattartás menedzsment jellegű, dokumentációs feladatai [pl.: konfigurációk nyilvántartása, verziók menedzselése, dokumentáció menedzselése] + + \item Dokumentáció + + Egy nagy méretű program önmagában nem tekinthető szoftverterméknek + dokumentáció nélkül. Egy jó dokumentáció a következőképp épül fel. + \begin{itemize} + \item Felhasználói leírás + \begin{itemize} + \item Feladatleírás + \item Futtató környezet + \item Fejlesztések, verziók + \item Installálás + \item Használat + \item Készítők + \end{itemize} + \item Fejlesztői leírás + \begin{itemize} + \item Modulok (és azok szerkezete) + \item Osztályok (és azok kapcsolata) + \item Rendszer dinamikus viselkedése + \item Osztályok implementálása (adatszerkezetek, sablon osztályok) + \item Tesztelés + \end{itemize} + \end{itemize} +\end{enumerate} + +\subsection{Fejlesztési fázisok kapcsolatai} + +A fejlesztési fázisok leírására többféle modellt használhatunk +\begin{enumerate} + \item Vízesés modell + + Az egyes fázisok egymást követik, a + módosítások a futtatási eredmények ismeretében történnek. Egy bizonyos + fázisban elvégzett módosítás az összes rákövetkező fázist is érinti. + + \begin{figure}[H] + \centering + \includegraphics[width=0.5\textwidth]{img/vizeses.png} + \caption{Vízesés modell} + \label{fig:vizeses} + \end{figure} + + Hárányai: + \begin{itemize} + \item Új szolgáltatás minden fázison módosítást igényel + \item Validáció az egész életciklus megismétlését követelheti meg + \end{itemize} + \item Evolúciós modell + + A megoldást közelítő verzióinak, prototípusainak sorozatát + állítjuk egymás után elő, és így haladunk lépésenként egészen a végleges + megoldásig. Ennek során egy verzió elkészítésekor a specifikáció, a fejlesztés és a validáció párhuzamosan történik. + + \begin{figure}[H] + \centering + \includegraphics[width=0.5\textwidth]{img/evolucios.png} + \caption{Evolúciós modell} + \label{fig:evolucios} + \end{figure} + + Hárányai: + \begin{itemize} + \item Nehéz a projekt áttekintése + \item A gyors fejlesztés rendszerint a dokumentáltság rovására megy. + \end{itemize} + \item Boehm-féle spirális modell + + Ez a modell egy iterációs modell. Az iteráció a spirális egy + fázisával modellezhető, amely négy szakaszra bontható: + \begin{enumerate} + \item Célok, utak, alternatívák, korlátozások definiálása + \item Kockázatelemzés, stratégia kidolgozás + \item Feladat megoldása, validáció + \item Következő iteráció megtervezése + \end{enumerate} + + \begin{figure}[H] + \centering + \includegraphics[width=0.4\textwidth]{img/spiral.png} + \caption{Evolúciós modell} + \label{fig:spiral} + \end{figure} + + Hárányai: + \begin{itemize} + \item A modell alkalmazása általában munkaigényes, bonyolult feladat. + \item A projekt kidolgozásához szükséges szakembereket nem könnyű + gazdaságosan foglalkoztatni. + \end{itemize} +\end{enumerate} + +\section{SOLID tervezési elvek} +Az objektumorientált programozásban a SOLID egy mozaikszó, amely az öt tervezési alapelv (Single responsibility principle, Open/closed principle, Liskov substitution principle, Interface segregation principle, Dependency inversion principle) kezdőbetűjéből áll, és célja, hogy a szoftvertervezést még érthetőbbé, rugalmasabbá és karbantarthatóbbá tegye. A SOLID-nak semmi köze a felelősségek hozzárendelésének általános mintáihoz (General Responsibility Assignment Software Patterns, GRASP). A S.O.L.I.D. alapelvek szülőatyja Robert Cecil Martin amerikai mérnök informatikus és tanácsadó, aki nem csak a ``tiszta kód mozgalom'' vezérszónoka, hanem többek között az Agile Manifesto egyik eredeti megfogalmazója is. Ezek az alapelvek adják a magját az agilis szoftverfejlesztésnek vagy adaptív szoftverfejlesztésnek. Az elméletét Martin Design Principles and Design Patterns című könyvében mutatta be, de mint mozaikszó csak később Michael Feathers révén terjedt el. + +\begin{itemize} + \item {\textbf {Egyetlen felelősség elve - Single Responsibility Principle}} Egy osztály vagy modul egy, és csak egy felelősséggel rendelkezzen (azaz: egy oka legyen a változásra). + \item {\textbf {Nyílt/zárt elv - Open/Closed Principle}} Egy osztály vagy modul legyen nyílt a kiterjesztésre, de zárt a módosításra. + \item {\textbf {Liskov helyettesítési elv - Liskov substitution principle}} Minden osztály legyen helyettesíthető a leszármazott osztályával anélkül, hogy a program helyes működése megváltozna. + \item {\textbf {Interfész elválasztási elv - Interface segregation principle}} Az interfészek (kapcsolódási felületek) szétválasztásának elve: egyetlen kliens se legyen rákényszerítve arra, hogy olyan eljárásoktól függjön, amelyeket nem is használ. + \item {\textbf {Függőség megfordítási elv - Dependency inversion principle}} A magas szintű modulok ne függjenek az alacsony szintű moduloktól. Mindkettő absztrakcióktól függjön. +\end{itemize} + +\section{Architekturális minták (MV, MVC stb.)} + +\subsection{MVC} +A modell-nézet-vezérlő (MNV) (angolul model-view-controller) a szoftvertervezésben használatos programtervezési minta. Összetett, sok adatot a felhasználó elé táró számítógépes alkalmazásokban gyakori fejlesztői kívánalom az adathoz (modell) és a felhasználói felülethez (nézet) tartozó dolgok szétválasztása, hogy a felhasználói felület ne befolyásolja az adatkezelést, és az adatok átszervezhetők legyenek a felhasználói felület változtatása nélkül. A modell-nézet-vezérlő ezt úgy éri el, hogy elkülöníti az adatok elérését és az üzleti logikát az adatok megjelenítésétől és a felhasználói interakciótól egy közbülső összetevő, a vezérlő bevezetésével. + +Hagyományosan asztali felhasználói felületekhez használt, de manapság már webalkalmazásokhoz is népszerűvé vált. Népszerű programozási nyelvek mint a JavaScript, Python, Ruby, PHP, Java már külön telepítés szükségessége nélkül rendelkeznek MNV keretrendszerekkel web- és mobilalkalmazások fejlesztésére. + +Gyakori egy alkalmazás több rétegre való felbontása: megjelenítés (felhasználói felület), tartománylogika és adatelérés. Az MNV-ben a megjelenítés tovább bomlik nézetre és vezérlőre. Az MNV sokkal inkább meghatározza egy alkalmazás szerkezetét, mint az egy programtervezési mintára jellemző. +\begin{description} + \item[Modell (Model)] \hfill \\ + Az alkalmazás által kezelt információk tartomány-specifikus ábrázolása. A tartománylogika jelentést ad a puszta adatnak (pl. kiszámolja, hogy a mai nap a felhasználó születésnapja-e, vagy az összeget, adókat és szállítási költségeket egy vásárlói kosár elemeihez). + + Sok alkalmazás használ állandó tároló eljárásokat (mint mondjuk egy adatbázis) adatok tárolásához. Az MNV nem említi külön az adatelérési réteget, mert ezt beleérti a modellbe. + \item[Nézet (View)] \hfill \\ + Megjeleníti a modellt egy megfelelő alakban, mely alkalmas a felhasználói interakcióra, jellemzően egy felhasználói felületi elem képében. Különböző célokra különböző nézetek létezhetnek ugyanahhoz a modellhez. + \item[Vezérlő (Controller)] \hfill \\ + Az eseményeket, jellemzően felhasználói műveleteket dolgozza fel és válaszol rájuk, illetve a modellben történő változásokat is kiválthat.[8] +\end{description} + +Az MNV gyakran látható webalkalmazásokban, ahol a nézet az aktuális HTML oldal, a vezérlő pedig a kód, ami összegyűjti a dinamikus adatokat és létrehozza a HTML-ben a tartalmat. Végül a modellt a tartalom képviseli, ami általában adatbázisban vagy XML állományokban van tárolva. + +Habár az MNV-nek sok értelmezése létezik, a vezérlés menete általánosságban a következőképp működik:[9] +\begin{itemize} + \item A felhasználó valamilyen hatást gyakorol a felhasználói felületre (pl. megnyom egy gombot). + \item A vezérlő átveszi a bejövő eseményt a felhasználói felülettől, gyakran egy bejegyzett eseménykezelő vagy visszahívás útján. + \item A vezérlő kapcsolatot teremt a modellel, esetleg frissíti azt a felhasználó tevékenységének megfelelő módon (pl. a vezérlő frissíti a felhasználó kosarát). Az összetett vezérlőket gyakran alakítják ki az utasítás mintának megfelelően, a műveletek egységbezárásáért és a bővítés egyszerűsítéséért. + \item A nézet (közvetve) a modell alapján megfelelő felhasználói felületet hoz létre (pl. a nézet hozza létre a kosár tartalmát felsoroló képernyőt). A nézet a modellből nyeri az adatait. A modellnek nincs közvetlen tudomása a nézetről. + \item A felhasználói felület újabb eseményre vár, mely az elejéről kezdi a kört. +\end{itemize} + +A modell és a nézet kettéválasztásával az MNV csökkenti a szerkezeti bonyolultságot, és megnöveli a rugalmasságot és a felhasználhatóságot. + +\begin{description} + \item[Szolgáltatás (Service)] \hfill \\ + A vezérlő és a modell közötti réteg. A modelltől kér le adatokat és a vezérlőnek adja azt. Ennek a rétegnek a segítségével az adat tárolás (modell), adat lekérés (szolgáltatás) és a adat kezelés (vezérlő) elkülöníthetőek egymástól. Mivel ez a réteg nem része az eredeti MNV mintának, ezért használata nem kötelező. +\end{description} + +\begin{description} + \item[Előnyök:] \hfill + \begin{itemize} + \item Egyidejű fejlesztés – Több fejlesztő tud egyszerre külön a modellen, vezérlőn és a nézeteken dolgozni. + \item Magas szintű összetartás – MNV segítségével az összetartozó funkciók egy vezérlőben csoportosíthatóak. Egy bizonyos modell nézetei is csoportosíthatóak. + \item Függetlenség – MNV mintában az elemek alapvetően nagy részben függetlenek egymástól + \item Könnyen változtatható – Mivel a felelősségek szét vannak választva a jövőbeli fejlesztések könnyebbek lesznek + \item Több nézet egy modellhez – Modelleknek több nézetük is lehet + \item Tesztelhetőség - mivel a felelősségek tisztán szét vannak választva, a külön elemek könnyebben tesztelhetőek egymástól függetlenül + \end{itemize} + \item[Hátrányok:] \hfill \\ + A MNV hátrányait általában a szükséges extra kódból adódnak. + \begin{itemize} + \item Kód olvashatósága – A keretrendszer új rétegeket add a kódhoz ami megnöveli a bonyolultságát + \item Sok boilerplate kód – Mivel a programkód 3 részre bomlik a ebből az egyik fogja a legtöbb munkát végezni a másik kettő pedig az MNV minta kielégítése miatt létezik.' + \item Nehezebben tanulható – A fejlesztőnek több különböző technológiát is ismernie kell a MNV használatához. + \end{itemize} +\end{description} + +\section{Tervezési minták szerepe, osztályozása, és kategóriánként 2-2 nevezetes tervezési minta bemutatása.} +Az informatikában a programtervezési mintának (angolul Software Design Patterns) nevezik a gyakran előforduló programozási feladatokra adható általános, újrafelhasználható megoldásokat. Egy programtervezési minta rendszerint egymással együttműködő objektumok és osztályok leírása. + +A tervminták nem nyújtanak kész tervet, amit közvetlenül le lehet kódolni, habár vannak hozzájuk példakódok, amiket azonban meg kell tölteni az adott helyzetre alkalmas kóddal. Céljuk az, hogy leírást vagy sablont nyújtsanak. Segítik formalizálni a megoldást. + +A minták rendszerint osztályok és objektumok közötti kapcsolatokat mutatnak, de nem specifikálják konkrétan a végleges osztályokat vagy objektumokat. A modellek absztrakt osztályai helyett egyes esetekben interfészek is használhatók, habár azokat maga a tervminta nem mutatja. Egyes nyelvek beépítetten tartalmaznak tervmintákat. A tervminták tekinthetők a strukturált programozás egyik szintjének a paradigma és az algoritmus között. + +A legtöbb tervminta objektumorientált környezetre van kidolgozva. Mivel a funkcionális programozás kevéssé ismert és használt, arra a környezetre még csak kevés tervminta ismert, például a monád. Az objektumorientált minták közül nem mindegyiket lehet, és nem mindegyiket érdemes itt használni. Van, amit módosítani kell. + +A programtervezési minták a 90-es évek elején (1994) tettek szert népszerűségre, amikor a négyek bandájaként vagy gammáékként (angolul "Gang of Four" vagy GoF)-ként emlegetett Erich Gamma, Richard Helm, Ralph Johnson és John Vlissides programozó négyes kiadta a Programtervezési minták című könyvüket, amely ma is alapjául szolgál az objektumorientált programozási minták kutatásának. Magát a tervmintát nem definiálták. A fogalom maga évekig formalizálatlan maradt. + +Ez a könyv összesen 23 mintát mutat be, és a következő kategóriákba sorolja őket: +\begin{itemize} + \item létrehozási minta + \item szerkezeti minta + \item viselkedési minta +\end{itemize} + +A programtervezési minták a GoF definíciója szerint: egymással együttműködő objektumok és osztályok leírásai, amelyek testre szabott formában valamilyen általános tervezési problémát oldanak meg egy bizonyos összefüggésben. A szoftvertervezésben egy-egy problémára végtelen sok különböző megoldás adható, azonban ezek között kevés optimális van. Tapasztalt szoftvertervezők, akik már sok hasonló problémával találkoztak, könnyen előhúzhatnak egy olyan megoldást, amely már kipróbált és bizonyított. Kezdő fejlesztőknek viszont jól jön, ha mindazt a tudást és tapasztalatot, amit csak évek munkájával érhetnek el, precízen dokumentálva kézbe vehetik, tanulhatnak belőle és az általa bevezetett kifejezésekkel könnyebben beszélhetik meg egymás között az ötleteiket. A programtervezési minták ilyen összegyűjtött tapasztalatok, amelyek mindegyike egy-egy gyakran előforduló problémára ad általánosított választ. Azonban mindezek mellett még számos előnyük van: + +\begin{itemize} + \item lerövidítik a tapasztalatszerzési időt. A programtervezési mintákat nem feltalálták, hanem a gyakran előforduló problémákra adott optimális válaszokat gyűjtötték össze, ezáltal olyan megoldásokat adtak, amelyekre előbb-utóbb a legtöbb fejlesztő magától is rájönne – csak esetleg jóval később. Természetesen nem kizárt, hogy léteznek jobb, hatékonyabb megoldások, és ritka amikor egy-egy mintát pontosan úgy lehet alkalmazni egy problémára, ahogy az a könyvekben le van írva, de mindenképpen érdemes megismerni őket, ha másért nem is, hogy elsajátíthassunk valamennyit a szerzők látásmódjából. + \item lerövidítik a tervezési időt. Az összes minta jól dokumentált, könnyen újrafelhasználható, így ha egyszer alkalmazzuk őket, jó eséllyel egy hasonló problémánál újra eszünkbe fognak jutni az összes előnyükkel és hátrányukkal együtt. Így azonnal hatékony, rugalmas megoldást adhatunk és megkímélhetjük magunkat sok tervezéstől és esetleges újratervezéstől. Ráadásul a minták után található következmények rész elősegíti, hogy teljesebb képet kapjunk az alkalmazás hatásairól is. + \item közös szótárat ad a fejlesztők kezébe. Ez megkönnyíti az egymás közti kommunikációt és a program dokumentálását is, hiszen könnyebb úgy beszélni egy probléma megoldásáról, ha van egy közös alap, ahonnan indulunk vagy amihez lehet hasonlítani az új terveket. + \item magasabb szintű programozást tesz lehetővé. Mivel ezek a minták elterjedtségük miatt már kiállták nagyon sok programozó próbáját, feltehetőleg az optimális megoldást tartalmazzák a problémára. +\end{itemize} + +A tervezési minták a modulokat és kapcsolataikat szervezik. Alacsonyabb szintűek, mint az architekturális minták, amelyek a teljes rendszer általános felépítését jellemzik. + +Több különböző tervminta létezik, például: +\begin{itemize} + \item Algoritmus stratégia minták + \item Magas szintű stratégiák, amelyek leírják, hogyan kell algoritmust szervezni egy adott architektúrára. + \item Számítástervezési minták + \item A kulcsfontosságú számítások megkeresését célozzák. + \item Végrehajtási minták + \item A végrehajtás alacsonyabb szintjén címzésekkel, feladatok végrehajtásának szervezésével, optimalizálásával, szinkronizálásával foglalkozó minták. + \item Implementációs stratégia minták + \item A forráskód implementációjában támogatják a program szervezését, és a párhuzamos programozás számára fontos adatszerkezetek felépítését. + \item Szerkezeti tervezési minták + \item Az alkalmazás globális struktúrájával foglalkoznak. +\end{itemize} + +A tervmintákat Gammáék eredetileg három kategóriába csoportosították: létrehozási minták, szerkezeti minták, és viselkedési minták, amihez használták a delegálás, az aggregálás, és a konzultáció fogalmát. Objektumorientált környezetben az öröklődés, polimorfizmus és az absztrakt ősosztály fogalmait is felhasználják, habár az absztrakt osztályok többnyire interfészek is lehetnek. Egyes szerzők elkülönítik az architekturális tervezési mintákat is, mint a modell-nézet-vezérlő. + +\subsection{Létrehozási minták (Egyke, Prototípus)} + +\subsubsection{Egyke (Singleton)} +Biztosítja, hogy az osztályból csak egy példány készül, és biztosít egy publikus hozzáférést ehhez a példányhoz. + +Az egyke programtervezési minta olyan programtervezési minta, amely egy objektumra korlátozza egy osztály létrehozható példányainak számát. Gyakori, hogy egy osztályt úgy kell megírni, hogy csak egy példány lehet belőle. Ehhez jól kell ismerni az objektumorientált programozás alapelveit. Az osztályból példányt a konstruktorával lehet készíteni. Ha van publikus konstruktor az osztályban, akkor akárhány példány készíthető belőle, tehát publikus konstruktora nem lehet az egykének. De ha nincs konstruktor, akkor nem hozható létre a példány, amin keresztül hívhatnánk a metódusait. A megoldást az osztályszintű (statikus) metódusok jelentik. Ezeket akkor is lehet hívni, ha nincs példány. Az egykének tehát van egy osztályszintű metódusa (szerezPéldány, angolul getInstance), ami minden hívójának ugyanazt a példányt adja vissza. Természetesen ezt a példányt is létre kell hozni, ehhez privát konstruktort kell készíteni, amit a szerezPéldány az egyke osztály tagjaként meghívhat. + +\subsubsection{Prototípus (Prototype)} +Meghatároz egy előzetes mintát az objektumok létrehozásához, és később ez kerül másolásra. Gyakran használjuk, ha az objektum pontos típusa csak futásidőben derül ki. + +A prototípus tervezési minta fő technikája a klónozás. A klónozás feladata, hogy az eredeti objektummal megegyező objektumot hozzon létre. Erre az egyszerű értékadás nem alkalmas, mert azok csak az objektum referenciáját másolják, így a két referencia ugyanoda mutat. A klónozásnak két fajtája van: sekély klónozás (angolul: shallow copy) és mély klónozás (angolul: deep copy). + +\subsection{Szerkezeti minták (Díszítő, Helyettes)} + +\subsubsection{Díszítő (Decorator)} +Lehetővé teszi az absztrakció változtatása nélkül további funkciók, felelősségi körök dinamikus hozzáadását. + +A díszítő minta az átlátszó csomagolás klasszikus példája. Klasszikus példája a karácsonyfa. Attól, hogy a karácsonyfára felteszek egy gömböt, az még karácsonyfa marad, azaz a díszítés átlátszó. Ezt úgy érjük el, hogy az objektum összetételben szereplő mindkét osztály ugyanazon őstől származik, azaz ugyanolyan típusúak. Ez azért hasznos, mert a díszítő elemek gyakran változnak, könnyen elképzelhető, hogy új díszt kell felvenni. Ha díszítő egy külön típus lenne, akkor a karácsonyfa feldolgozó algoritmusok esetleg bonyolultak lehetnek. + +A díszítő mintánál egy absztrakt ősből indulunk ki. Ennek kétfajta gyermeke van, alap osztályok, amiket díszíteni lehet és díszítő osztályok. A karácsonyfa példa esetén az alap osztályok a különböző fenyőfák. A díszítő osztályokat általában egy absztrakt díszítő osztály alá szervezzük, de ez nem kötelező. + +A díszítés során az ős minden metódusát implementálni kell, úgy hogy, a becsomagolt példány metódusát meghívjuk, illetve ahol ez szükséges, ott hozzáadjuk a plusz funkcionalitást. Kétféle díszítésről beszélhetünk: +\begin{itemize} + \item Amikor a meglévő metódusok felelősségkörét bővítjük. Ilyen a karácsonyfás példa. + \item Amikor új metódusokat is hozzáadunk a meglévőkhöz. Ilyen a Java adatfolyam (angolul: stream) kezelése, illetve a lenti kölcsönözhető jármű példa. +\end{itemize} + +Mindkét esetben a példányosítás tipikusan így történik: + +ŐsOsztály példány = new DíszítőN(…new Díszítő1( new AlapOsztály())…); + +Mivel a csomagolás átlátszó, ezért akárhányszor becsomagolhatjuk a példányunkat, akár egy díszítővel kétszer is. Ez rendkívül dinamikus, könnyen bővíthető szerkezetet eredményez, amit öröklődéssel csak nagyon sok osztállyal lehetne megvalósítani. + +Érdekes megfigyelni a minta UML ábráján, hogy a díszítő osztályból visszafelé mutat egy aggregáció az ős osztályra. Ez az adatbázis kezelés Alkalmazott - Főnök reláció megoldásához hasonlít, amikor az Alkalmazott tábla önmagával áll egy-több kapcsolatban, ahol a külső kulcs a főnök alkalmazott\_ID értékét tartalmazza. + +\subsubsection{Helyettes (Proxy)} +Egy másik objektum elfedésére, helyettesítésére alkalmazott tervezési minta. + +A helyettes (angolul: proxy) tervezési minta egy nagyon egyszerű kompozícióra ad példát, ami ráadásul átlátszó becsomagolás. Egy valamilyen szempontból érdekes (drága, távoli, biztonsági szempontból érzékeny, …) példányt birtokol a helyettese. Ez az érdekes objektum nem érhető el kívülről, csak a helyettesén keresztül érhetők el a szolgáltatásai. Ugyanakkor a külvilág azt hiszi, hogy az érdekes objektumot közvetlenül éri el, mert a helyettes átlátszó módon csomagolja be az érdekes objektumot. Az átlátszóság miatt a helyettesnek és az érdekes objektumnak közös őse van. + +Sokféle helyettes létezik aszerint, hogy milyen szempontból érdekes a helyettesített objektum, pl.: +\begin{itemize} + \item Virtuális proxy: Nagy erőforrás igényű objektumok (pl. kép) helyettesítése a példányosítás (vagy más drága művelet) elhalasztásával, amíg ez lehetséges. A szövegszerkesztők ezt használják a képek betöltésére. Ha csak gyorsan átlapozom a dokumentumot, akkor a kép nem töltődik be (elhalasztódik a betöltés), csak helye látszik. + \item Távoli proxy: Távoli objektumok lokális megjelenítése átlátszó módon. A kliens nem is érzékeli, hogy a tényleges objektum egy másik gépen van, amíg van hálózati kapcsolat. Ezt alkalmazza a távoli metódus hívás (remote method invocation – RMI). + \item Védelmi proxy: A hozzáférést szabályozza különböző jogok esetén. + \item Okos referencia: Az egyszerű referenciát helyettesíti olyan esetekben, amikor az objektum elérésekor további műveletek szükségesek. + \item Gyorsító tár (cache): Ha van olyan számítás (ide sorolva a letöltéseket is), ami drága, akkor a számítás eredményét érdemes letárolni egy gyorsító tárban, ami szintén egyfajta proxy. +\end{itemize} + +\subsection{Viselkedési minták (Állapot, Megfigyelő)} + +\subsubsection{Állapot (State)} +Az objektum viselkedése megváltoztatható a belső állapottól függően. + +Lehetővé teszi egy objektum viselkedésének megváltozását, amikor megváltozik az állapota. Példa: TCPConnection osztály egy hálózati kapcsolatot reprezentál; Három állapota lehet: Listening, Established, Closed; a kéréseket az állapotától függően kezeli. + +Használjuk, ha +\begin{itemize} + \item az objektum viselkedése függ az állapotától, és a viselkedését az aktuális állapotnak megfelelően futás közben meg kell változtatnia, illetve + \item a műveleteknek nagy feltételes ágai vannak, melyek az objektum állapotától függenek. +\end{itemize} + +Előnyök: +\begin{itemize} + \item Egységbe zárja az állapotfüggő viselkedést, így könnyű új állapotok bevezetése. + \item Áttekinthetőbb kód (nincs nagy switch-case szerkezet). + \item A State objektumokat meg lehet osztani. +\end{itemize} + +Hátrányok: Nő az osztályok száma (csak indokolt esetben használjuk). + +\subsubsection{Megfigyelő (Observer)} +Meghatároz ez egy-a-többhöz függőséget objektumok között. Egy adott objektum módosulásáról automatikus értesítő információt küld a tőle függő objektumoknak, amik ezek alapján frissülnek. + +ehetővé teszi, hogy egy objektum megváltozása esetén értesíteni tudjon tetszőleges más objektumokat anélkül, hogy bármit is tudna róluk. Részei: +\begin{itemize} + \item Alany: Tárolja a beregisztrált megfigyelőket, interfészt kínál a megfigyelők be- és kiregisztrálására valamint értesítésére. + \item Megfigyelő: Interfészt definiál azon objektumok számára, amelyek értesülni szeretnének az alanyban bekövetkezett változásról. Erre a frissít (update) metódus szolgál. +\end{itemize} + +Két fajta megfigyelő megvalósítást ismerünk: +\begin{itemize} + \item ``Pull-os'' megfigyelő: Ebben az esetben a megfigyelő lehúzza a változásokat az alanytól. + \item ``Push-os'' megfigyelő: Ebben az esetben az alany odanyomja a változásokat a megfigyelőnek. +\end{itemize} + +A kettő között ott van a különbség, hogy a frissít metódus milyen paramétert kap. Ha az alany átadja önmagát (egy frissít(this) hívás segítségével) a megfigyelőnek, akkor ezen a referencián keresztül a megfigyelő képes lekérdezni a változásokat. Azaz ez a ``pull-os'' megoldás. + +Ha a frissít metódusnak az alany azokat a mezőit adja át, amik megváltoztak és amiket a megfigyelő figyel, akkor ``push-os'' megoldásról beszélünk. A következő példában épp egy ilyen megvalósítást láthatunk. + +\end{document} \ No newline at end of file diff --git a/8.Programfejlesztési modellek/img/evolucios.png b/9. Objektumelvű tervezés/img/evolucios.png similarity index 100% rename from 8.Programfejlesztési modellek/img/evolucios.png rename to 9. Objektumelvű tervezés/img/evolucios.png diff --git a/8.Programfejlesztési modellek/img/kovetelmenyleiras.png b/9. Objektumelvű tervezés/img/kovetelmenyleiras.png similarity index 100% rename from 8.Programfejlesztési modellek/img/kovetelmenyleiras.png rename to 9. Objektumelvű tervezés/img/kovetelmenyleiras.png diff --git a/8.Programfejlesztési modellek/img/nemfunkckov.png b/9. Objektumelvű tervezés/img/nemfunkckov.png similarity index 100% rename from 8.Programfejlesztési modellek/img/nemfunkckov.png rename to 9. Objektumelvű tervezés/img/nemfunkckov.png diff --git a/8.Programfejlesztési modellek/img/spiral.png b/9. Objektumelvű tervezés/img/spiral.png similarity index 100% rename from 8.Programfejlesztési modellek/img/spiral.png rename to 9. Objektumelvű tervezés/img/spiral.png diff --git a/8.Programfejlesztési modellek/img/vizeses.png b/9. Objektumelvű tervezés/img/vizeses.png similarity index 100% rename from 8.Programfejlesztési modellek/img/vizeses.png rename to 9. Objektumelvű tervezés/img/vizeses.png diff --git a/PTI BSc ZV tetelek 2018-as tantervhez.pdf b/PTI BSc ZV tetelek 2018-as tantervhez.pdf new file mode 100644 index 0000000..fdee19f Binary files /dev/null and b/PTI BSc ZV tetelek 2018-as tantervhez.pdf differ diff --git a/README.md b/README.md index 4f540c7..f119b40 100644 --- a/README.md +++ b/README.md @@ -1,8 +1,40 @@ -# ELTE IK - Bsc Záróvizsga 2015 tavaszi félév +# ELTE IK - Prog.Inf. BSc Záróvizsga tételek kidolgozása -Ebben a projektben a 2015. év tavaszi félév záróvizsgájának tételsora került kidolgozásra. A tételek kellő részletességel a tananyag megértését szolgálják, - további ismeretanyagok szüksége nélküli szemléltben íródtak. Ennek tükrében néhány tétel olykor esetleg terjedelmesebb, mint ahogy azt a vizsgán prezentálni szükséges. - -A szerzők belegyezésével a tételkidolgozás szabadon felhasználható. - -Szerzők: **Ancsin Ádám**, **Bálint Márton**, **Dobreff András**, és **Fekete Dóra** \ No newline at end of file +## Programtervező Informatikus BSc Záróvizsga tételek 2018-as tantervhez + +1. Függvények határértéke, folytonossága +2. Differenciál- és integrálszámítás +3. Numerikus módszerek +4. Számelmélet, gráfok, (Kódoláselmélet) +5. Valószínűségszámítási és statisztikai alapok +6. Mesterséges intelligencia +7. Programozás +8. Objektumelvű modellezés +9. Objektumelvű tervezés +10. Programnyelvi alapok +11. Objektumelvű programozási nyelvek +12. Formális nyelvek és automaták +13. Számításelmélet (és Logika) +14. Alapvető algoritmusok +15. Adatszerkezetek és adattípusok +16. Haladó algoritmusok +17. Operációs rendszerek +18. Számítógépes hálózatok és Internet eszközök +19. Osztott rendszerek és konkurens programozás +20. Adatbázisok tervezése és lekérdezése +21. Adatbázisok optimalizálása és konkurencia kezelése +22. Funkcionális programozás + +## Segíts javítani és bővíteni a tételkidolgozásokat! + +A `TODO.md`-ben találod a hiányosságokat, hibákat. + +Fejlesztés VS Code-al: + +1. Tölts le egy LaTeX disztribúciót. Pl: [MiKTeX](https://miktex.org/download) +2. Klónozd a repót és nyisd meg VS Code-al, telepítsd az ajánlott bővítményeket. +3. Fordításnál telepítsd a felugró TeX bővítményeket. + +--- + +**Ancsin Ádám**, **Bálint Márton**, **Dobreff András**, és **Fekete Dóra** szerzők LaTeX kidolgozásai (2015) alapján és engedélyével. diff --git a/Régebbi záróvizsga kidolgozások/2011/01 - Sorozatok, sorok, függvények határértéke és folytonossága (Ismeretlen, 2010).pdf b/Régebbi záróvizsga kidolgozások/2011/01 - Sorozatok, sorok, függvények határértéke és folytonossága (Ismeretlen, 2010).pdf new file mode 100644 index 0000000..06ecba8 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2011/01 - Sorozatok, sorok, függvények határértéke és folytonossága (Ismeretlen, 2010).pdf differ diff --git a/Régebbi záróvizsga kidolgozások/2011/02 - Differenciálszámítás, integrálszámítás és alkalmazásaik (S.R., 2010).pdf b/Régebbi záróvizsga kidolgozások/2011/02 - Differenciálszámítás, integrálszámítás és alkalmazásaik (S.R., 2010).pdf new file mode 100644 index 0000000..f6c4fe9 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2011/02 - Differenciálszámítás, integrálszámítás és alkalmazásaik (S.R., 2010).pdf differ diff --git a/Régebbi záróvizsga kidolgozások/2011/03 - Differenciálegyenlet rendszerek (Piri Zoltán, 2011).pdf b/Régebbi záróvizsga kidolgozások/2011/03 - Differenciálegyenlet rendszerek (Piri Zoltán, 2011).pdf new file mode 100644 index 0000000..0d3c434 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2011/03 - Differenciálegyenlet rendszerek (Piri Zoltán, 2011).pdf differ diff --git a/Régebbi záróvizsga kidolgozások/2011/04 - Interpolációs eljárások (Ismeretlen, 2010).pdf b/Régebbi záróvizsga kidolgozások/2011/04 - Interpolációs eljárások (Ismeretlen, 2010).pdf new file mode 100644 index 0000000..a86e363 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2011/04 - Interpolációs eljárások (Ismeretlen, 2010).pdf differ diff --git a/Régebbi záróvizsga kidolgozások/2011/05 - Lineáris egyenletrendszerek numerikus megoldása (Bognár Bálint, 2011).pdf b/Régebbi záróvizsga kidolgozások/2011/05 - Lineáris egyenletrendszerek numerikus megoldása (Bognár Bálint, 2011).pdf new file mode 100644 index 0000000..d0d44a1 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2011/05 - Lineáris egyenletrendszerek numerikus megoldása (Bognár Bálint, 2011).pdf differ diff --git a/Régebbi záróvizsga kidolgozások/2011/06 - Számelmélet és rejtjelezési eljárások (Bognár Bálint, 2011).pdf b/Régebbi záróvizsga kidolgozások/2011/06 - Számelmélet és rejtjelezési eljárások (Bognár Bálint, 2011).pdf new file mode 100644 index 0000000..44a096d Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2011/06 - Számelmélet és rejtjelezési eljárások (Bognár Bálint, 2011).pdf differ diff --git a/Régebbi záróvizsga kidolgozások/2011/07 - Kódoláselmélet (Bognár Bálint, 2011).pdf b/Régebbi záróvizsga kidolgozások/2011/07 - Kódoláselmélet (Bognár Bálint, 2011).pdf new file mode 100644 index 0000000..3cbb088 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2011/07 - Kódoláselmélet (Bognár Bálint, 2011).pdf differ diff --git a/Régebbi záróvizsga kidolgozások/2011/07 - Kódoláselmélet (Ismeretlen, 2010).pdf b/Régebbi záróvizsga kidolgozások/2011/07 - Kódoláselmélet (Ismeretlen, 2010).pdf new file mode 100644 index 0000000..da68ad7 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2011/07 - Kódoláselmélet (Ismeretlen, 2010).pdf differ diff --git a/Régebbi záróvizsga kidolgozások/2011/08 - Lineáris algebrai alapok (Ismeretlen, 2010).pdf b/Régebbi záróvizsga kidolgozások/2011/08 - Lineáris algebrai alapok (Ismeretlen, 2010).pdf new file mode 100644 index 0000000..48a63aa Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2011/08 - Lineáris algebrai alapok (Ismeretlen, 2010).pdf differ diff --git a/Régebbi záróvizsga kidolgozások/2011/09 - Valószínűségszámítási és statisztikai alapok (Bognár Bálint, 2011).pdf b/Régebbi záróvizsga kidolgozások/2011/09 - Valószínűségszámítási és statisztikai alapok (Bognár Bálint, 2011).pdf new file mode 100644 index 0000000..ad0718d Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2011/09 - Valószínűségszámítási és statisztikai alapok (Bognár Bálint, 2011).pdf differ diff --git a/Régebbi záróvizsga kidolgozások/2011/10 - Mesterséges intelligencia (Bognár Bálint, 2011).pdf b/Régebbi záróvizsga kidolgozások/2011/10 - Mesterséges intelligencia (Bognár Bálint, 2011).pdf new file mode 100644 index 0000000..876c89f Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2011/10 - Mesterséges intelligencia (Bognár Bálint, 2011).pdf differ diff --git a/Régebbi záróvizsga kidolgozások/2011/11 - Programozási tételek (Ismeretlen, 2010).pdf b/Régebbi záróvizsga kidolgozások/2011/11 - Programozási tételek (Ismeretlen, 2010).pdf new file mode 100644 index 0000000..bb38886 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2011/11 - Programozási tételek (Ismeretlen, 2010).pdf differ diff --git a/Régebbi záróvizsga kidolgozások/2011/12 - Típus (Ismeretlen, 2010).pdf b/Régebbi záróvizsga kidolgozások/2011/12 - Típus (Ismeretlen, 2010).pdf new file mode 100644 index 0000000..fce44a0 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2011/12 - Típus (Ismeretlen, 2010).pdf differ diff --git a/Régebbi záróvizsga kidolgozások/2011/13 - Programfejlesztési modellek (Bognár Bálint, 2011).pdf b/Régebbi záróvizsga kidolgozások/2011/13 - Programfejlesztési modellek (Bognár Bálint, 2011).pdf new file mode 100644 index 0000000..2dd9518 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2011/13 - Programfejlesztési modellek (Bognár Bálint, 2011).pdf differ diff --git a/Régebbi záróvizsga kidolgozások/2011/13 - Programfejlesztési modellek (Boldizsár Szilárd, 2010).pdf b/Régebbi záróvizsga kidolgozások/2011/13 - Programfejlesztési modellek (Boldizsár Szilárd, 2010).pdf new file mode 100644 index 0000000..0ec106b Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2011/13 - Programfejlesztési modellek (Boldizsár Szilárd, 2010).pdf differ diff --git a/Régebbi záróvizsga kidolgozások/2011/14 - Statikus és dinamikus modellek (Bognár Bálint, 2011).pdf b/Régebbi záróvizsga kidolgozások/2011/14 - Statikus és dinamikus modellek (Bognár Bálint, 2011).pdf new file mode 100644 index 0000000..5c77908 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2011/14 - Statikus és dinamikus modellek (Bognár Bálint, 2011).pdf differ diff --git a/Régebbi záróvizsga kidolgozások/2011/14 - Statikus és dinamikus modellek (Boldizsár Szilárd, 2010).pdf b/Régebbi záróvizsga kidolgozások/2011/14 - Statikus és dinamikus modellek (Boldizsár Szilárd, 2010).pdf new file mode 100644 index 0000000..db1043c Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2011/14 - Statikus és dinamikus modellek (Boldizsár Szilárd, 2010).pdf differ diff --git a/Régebbi záróvizsga kidolgozások/2011/15 - Programok fordítása és végrehajtása (Cserép Máté, 2011).pdf b/Régebbi záróvizsga kidolgozások/2011/15 - Programok fordítása és végrehajtása (Cserép Máté, 2011).pdf new file mode 100644 index 0000000..4c876d4 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2011/15 - Programok fordítása és végrehajtása (Cserép Máté, 2011).pdf differ diff --git a/Régebbi záróvizsga kidolgozások/2011/16 - Adatok, műveletek és vezérlés (Lehóczky Döme, 2010).pdf b/Régebbi záróvizsga kidolgozások/2011/16 - Adatok, műveletek és vezérlés (Lehóczky Döme, 2010).pdf new file mode 100644 index 0000000..3dc15aa Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2011/16 - Adatok, műveletek és vezérlés (Lehóczky Döme, 2010).pdf differ diff --git a/Régebbi záróvizsga kidolgozások/2011/17 - Programszerkezet (Cserép Máté, 2011).pdf b/Régebbi záróvizsga kidolgozások/2011/17 - Programszerkezet (Cserép Máté, 2011).pdf new file mode 100644 index 0000000..4c55323 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2011/17 - Programszerkezet (Cserép Máté, 2011).pdf differ diff --git a/Régebbi záróvizsga kidolgozások/2011/18 - Fordítóprogramok (Cserép Máté, 2011).pdf b/Régebbi záróvizsga kidolgozások/2011/18 - Fordítóprogramok (Cserép Máté, 2011).pdf new file mode 100644 index 0000000..c0a9674 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2011/18 - Fordítóprogramok (Cserép Máté, 2011).pdf differ diff --git a/Régebbi záróvizsga kidolgozások/2011/19 - Logika (Bognár Bálint, 2011).pdf b/Régebbi záróvizsga kidolgozások/2011/19 - Logika (Bognár Bálint, 2011).pdf new file mode 100644 index 0000000..eeb0f06 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2011/19 - Logika (Bognár Bálint, 2011).pdf differ diff --git a/Régebbi záróvizsga kidolgozások/2011/20 - Számításelmélet (Ismeretlen, 2009).pdf b/Régebbi záróvizsga kidolgozások/2011/20 - Számításelmélet (Ismeretlen, 2009).pdf new file mode 100644 index 0000000..7b9e20c Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2011/20 - Számításelmélet (Ismeretlen, 2009).pdf differ diff --git a/Régebbi záróvizsga kidolgozások/2011/21 - Adatszerkezetek (Cserép Máté, 2011).pdf b/Régebbi záróvizsga kidolgozások/2011/21 - Adatszerkezetek (Cserép Máté, 2011).pdf new file mode 100644 index 0000000..63af1b7 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2011/21 - Adatszerkezetek (Cserép Máté, 2011).pdf differ diff --git a/Régebbi záróvizsga kidolgozások/2011/22 - Alapvető algoritmusok (Bognár Bálint, 2011).pdf b/Régebbi záróvizsga kidolgozások/2011/22 - Alapvető algoritmusok (Bognár Bálint, 2011).pdf new file mode 100644 index 0000000..ffb71f1 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2011/22 - Alapvető algoritmusok (Bognár Bálint, 2011).pdf differ diff --git a/Régebbi záróvizsga kidolgozások/2011/23 - Formális nyelvek (Bognár Bálint, 2011).pdf b/Régebbi záróvizsga kidolgozások/2011/23 - Formális nyelvek (Bognár Bálint, 2011).pdf new file mode 100644 index 0000000..7da549c Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2011/23 - Formális nyelvek (Bognár Bálint, 2011).pdf differ diff --git a/Régebbi záróvizsga kidolgozások/2011/24 - Operációs rendszerek - párhuzamos folyamatok (Angyal Gábor, 2010).pdf b/Régebbi záróvizsga kidolgozások/2011/24 - Operációs rendszerek - párhuzamos folyamatok (Angyal Gábor, 2010).pdf new file mode 100644 index 0000000..6b7aa50 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2011/24 - Operációs rendszerek - párhuzamos folyamatok (Angyal Gábor, 2010).pdf differ diff --git a/Régebbi záróvizsga kidolgozások/2011/25 - Operációs rendszerek - tárkezelés (Ismeretlen, 2010).pdf b/Régebbi záróvizsga kidolgozások/2011/25 - Operációs rendszerek - tárkezelés (Ismeretlen, 2010).pdf new file mode 100644 index 0000000..c450737 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2011/25 - Operációs rendszerek - tárkezelés (Ismeretlen, 2010).pdf differ diff --git a/Régebbi záróvizsga kidolgozások/2011/26 - Számítógépes hálózatok és Internet eszközök (Bognár Bálint, 2011).pdf b/Régebbi záróvizsga kidolgozások/2011/26 - Számítógépes hálózatok és Internet eszközök (Bognár Bálint, 2011).pdf new file mode 100644 index 0000000..6f02379 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2011/26 - Számítógépes hálózatok és Internet eszközök (Bognár Bálint, 2011).pdf differ diff --git a/Régebbi záróvizsga kidolgozások/2011/27 - Osztott rendszerek - AC szakirány (Bunyik Karina, 2010).pdf b/Régebbi záróvizsga kidolgozások/2011/27 - Osztott rendszerek - AC szakirány (Bunyik Karina, 2010).pdf new file mode 100644 index 0000000..05c4877 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2011/27 - Osztott rendszerek - AC szakirány (Bunyik Karina, 2010).pdf differ diff --git a/Régebbi záróvizsga kidolgozások/2011/27 - Osztott rendszerek - B szakirány (Lehóczky Döme, 2010).pdf b/Régebbi záróvizsga kidolgozások/2011/27 - Osztott rendszerek - B szakirány (Lehóczky Döme, 2010).pdf new file mode 100644 index 0000000..2c18f5f Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2011/27 - Osztott rendszerek - B szakirány (Lehóczky Döme, 2010).pdf differ diff --git a/Régebbi záróvizsga kidolgozások/2011/28 - Adatbázisok - adatmodellezés (Bognár Bálint, 2011).pdf b/Régebbi záróvizsga kidolgozások/2011/28 - Adatbázisok - adatmodellezés (Bognár Bálint, 2011).pdf new file mode 100644 index 0000000..4005657 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2011/28 - Adatbázisok - adatmodellezés (Bognár Bálint, 2011).pdf differ diff --git a/Régebbi záróvizsga kidolgozások/2011/29 - Adatbázisok - lekérdezés és időszerűsítés (Bognár Bálint, 2011).pdf b/Régebbi záróvizsga kidolgozások/2011/29 - Adatbázisok - lekérdezés és időszerűsítés (Bognár Bálint, 2011).pdf new file mode 100644 index 0000000..9830464 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2011/29 - Adatbázisok - lekérdezés és időszerűsítés (Bognár Bálint, 2011).pdf differ diff --git a/Régebbi záróvizsga kidolgozások/2011/PTI BSc ZV tetelek 2011.pdf b/Régebbi záróvizsga kidolgozások/2011/PTI BSc ZV tetelek 2011.pdf new file mode 100644 index 0000000..d00ab79 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2011/PTI BSc ZV tetelek 2011.pdf differ diff --git a/1.Függvények határértéke, folytonossága/tetel1.tex b/Régebbi záróvizsga kidolgozások/2015/1.Függvények határértéke, folytonossága/tetel1.tex similarity index 100% rename from 1.Függvények határértéke, folytonossága/tetel1.tex rename to Régebbi záróvizsga kidolgozások/2015/1.Függvények határértéke, folytonossága/tetel1.tex diff --git a/Régebbi záróvizsga kidolgozások/2015/10.Programnyelvi alapok/img/rekord.png b/Régebbi záróvizsga kidolgozások/2015/10.Programnyelvi alapok/img/rekord.png new file mode 100644 index 0000000..7ab54b8 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/10.Programnyelvi alapok/img/rekord.png differ diff --git a/10.Programnyelvi alapok/tetel10.tex b/Régebbi záróvizsga kidolgozások/2015/10.Programnyelvi alapok/tetel10.tex similarity index 100% rename from 10.Programnyelvi alapok/tetel10.tex rename to Régebbi záróvizsga kidolgozások/2015/10.Programnyelvi alapok/tetel10.tex diff --git a/11.Formális nyelvek/tetel11.tex b/Régebbi záróvizsga kidolgozások/2015/11.Formális nyelvek/tetel11.tex similarity index 100% rename from 11.Formális nyelvek/tetel11.tex rename to Régebbi záróvizsga kidolgozások/2015/11.Formális nyelvek/tetel11.tex diff --git a/Régebbi záróvizsga kidolgozások/2015/12.Logika és számításelmélet/img/igazsagertfa.png b/Régebbi záróvizsga kidolgozások/2015/12.Logika és számításelmélet/img/igazsagertfa.png new file mode 100644 index 0000000..a38796b Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/12.Logika és számításelmélet/img/igazsagertfa.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/12.Logika és számításelmélet/img/igazsagertfapelda.png b/Régebbi záróvizsga kidolgozások/2015/12.Logika és számításelmélet/img/igazsagertfapelda.png new file mode 100644 index 0000000..637ae5f Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/12.Logika és számításelmélet/img/igazsagertfapelda.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/12.Logika és számításelmélet/img/kdnf_pelda.png b/Régebbi záróvizsga kidolgozások/2015/12.Logika és számításelmélet/img/kdnf_pelda.png new file mode 100644 index 0000000..a577507 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/12.Logika és számításelmélet/img/kdnf_pelda.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/12.Logika és számításelmélet/img/kiterjigaztabla.png b/Régebbi záróvizsga kidolgozások/2015/12.Logika és számításelmélet/img/kiterjigaztabla.png new file mode 100644 index 0000000..061e9d2 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/12.Logika és számításelmélet/img/kiterjigaztabla.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/12.Logika és számításelmélet/img/kknf_pelda.png b/Régebbi záróvizsga kidolgozások/2015/12.Logika és számításelmélet/img/kknf_pelda.png new file mode 100644 index 0000000..926fd09 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/12.Logika és számításelmélet/img/kknf_pelda.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/12.Logika és számításelmélet/img/rezoluciopelda.png b/Régebbi záróvizsga kidolgozások/2015/12.Logika és számításelmélet/img/rezoluciopelda.png new file mode 100644 index 0000000..e63a5a3 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/12.Logika és számításelmélet/img/rezoluciopelda.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/12.Logika és számításelmélet/img/rezoluciopelda_levfa.png b/Régebbi záróvizsga kidolgozások/2015/12.Logika és számításelmélet/img/rezoluciopelda_levfa.png new file mode 100644 index 0000000..e4cef48 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/12.Logika és számításelmélet/img/rezoluciopelda_levfa.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/12.Logika és számításelmélet/img/rezolvens.png b/Régebbi záróvizsga kidolgozások/2015/12.Logika és számításelmélet/img/rezolvens.png new file mode 100644 index 0000000..c1e12b0 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/12.Logika és számításelmélet/img/rezolvens.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/12.Logika és számításelmélet/img/szemantikusfa.png b/Régebbi záróvizsga kidolgozások/2015/12.Logika és számításelmélet/img/szemantikusfa.png new file mode 100644 index 0000000..cb99cef Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/12.Logika és számításelmélet/img/szemantikusfa.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/12.Logika és számításelmélet/img/szerkfa.png b/Régebbi záróvizsga kidolgozások/2015/12.Logika és számításelmélet/img/szerkfa.png new file mode 100644 index 0000000..d4d4330 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/12.Logika és számításelmélet/img/szerkfa.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/12.Logika és számításelmélet/img/turinggep_pelda.png b/Régebbi záróvizsga kidolgozások/2015/12.Logika és számításelmélet/img/turinggep_pelda.png new file mode 100644 index 0000000..36bf5a4 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/12.Logika és számításelmélet/img/turinggep_pelda.png differ diff --git a/12.Logika és számításelmélet/tetel12.tex b/Régebbi záróvizsga kidolgozások/2015/12.Logika és számításelmélet/tetel12.tex similarity index 100% rename from 12.Logika és számításelmélet/tetel12.tex rename to Régebbi záróvizsga kidolgozások/2015/12.Logika és számításelmélet/tetel12.tex diff --git a/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Beszur.jpg b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Beszur.jpg new file mode 100644 index 0000000..92d9276 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Beszur.jpg differ diff --git a/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Beszurorend.jpg b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Beszurorend.jpg new file mode 100644 index 0000000..d94c7ce Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Beszurorend.jpg differ diff --git a/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Buborekrendezes.png b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Buborekrendezes.png new file mode 100644 index 0000000..fee394f Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Buborekrendezes.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/GyorsRend.jpg b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/GyorsRend.jpg new file mode 100644 index 0000000..aa8502d Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/GyorsRend.jpg differ diff --git a/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Helyrevisz.jpg b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Helyrevisz.jpg new file mode 100644 index 0000000..dc2501b Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Helyrevisz.jpg differ diff --git a/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Kezdokupac.jpg b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Kezdokupac.jpg new file mode 100644 index 0000000..d6641ef Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Kezdokupac.jpg differ diff --git a/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Kovetkezo.jpg b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Kovetkezo.jpg new file mode 100644 index 0000000..a3695be Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Kovetkezo.jpg differ diff --git a/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/KupacbaBeszur.jpg b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/KupacbaBeszur.jpg new file mode 100644 index 0000000..52bf28f Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/KupacbaBeszur.jpg differ diff --git a/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Kupacrend.jpg b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Kupacrend.jpg new file mode 100644 index 0000000..17bc068 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Kupacrend.jpg differ diff --git a/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Listaba.jpg b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Listaba.jpg new file mode 100644 index 0000000..928871b Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Listaba.jpg differ diff --git a/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/OfRend.jpg b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/OfRend.jpg new file mode 100644 index 0000000..b1fd125 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/OfRend.jpg differ diff --git a/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Sorba.jpg b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Sorba.jpg new file mode 100644 index 0000000..fc7f50a Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Sorba.jpg differ diff --git a/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Sorbol.jpg b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Sorbol.jpg new file mode 100644 index 0000000..8c4d031 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Sorbol.jpg differ diff --git a/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Sully.jpg b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Sully.jpg new file mode 100644 index 0000000..e3a8f17 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Sully.jpg differ diff --git a/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Torol.jpg b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Torol.jpg new file mode 100644 index 0000000..1772c31 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Torol.jpg differ diff --git a/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/VFaKitolt.jpg b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/VFaKitolt.jpg new file mode 100644 index 0000000..1177576 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/VFaKitolt.jpg differ diff --git a/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/VFaMax.jpg b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/VFaMax.jpg new file mode 100644 index 0000000..4372ff6 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/VFaMax.jpg differ diff --git a/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Verembe.jpg b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Verembe.jpg new file mode 100644 index 0000000..224620c Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Verembe.jpg differ diff --git a/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Verembol.jpg b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Verembol.jpg new file mode 100644 index 0000000..633083c Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Verembol.jpg differ diff --git a/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Versenyrend.jpg b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Versenyrend.jpg new file mode 100644 index 0000000..aa4f41c Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/Versenyrend.jpg differ diff --git a/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/ads.png b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/ads.png new file mode 100644 index 0000000..dafa6e9 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/img/ads.png differ diff --git a/13.Alapvető algoritmusok és adatszerkezetek/tetel13.tex b/Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/tetel13.tex similarity index 100% rename from 13.Alapvető algoritmusok és adatszerkezetek/tetel13.tex rename to Régebbi záróvizsga kidolgozások/2015/13.Alapvető algoritmusok és adatszerkezetek/tetel13.tex diff --git a/Régebbi záróvizsga kidolgozások/2015/14.Haladó algoritmusok/img/BoyerMoore.jpg b/Régebbi záróvizsga kidolgozások/2015/14.Haladó algoritmusok/img/BoyerMoore.jpg new file mode 100644 index 0000000..fe287c6 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/14.Haladó algoritmusok/img/BoyerMoore.jpg differ diff --git a/Régebbi záróvizsga kidolgozások/2015/14.Haladó algoritmusok/img/BoyerMoore_initshift.jpg b/Régebbi záróvizsga kidolgozások/2015/14.Haladó algoritmusok/img/BoyerMoore_initshift.jpg new file mode 100644 index 0000000..d2a962f Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/14.Haladó algoritmusok/img/BoyerMoore_initshift.jpg differ diff --git a/Régebbi záróvizsga kidolgozások/2015/14.Haladó algoritmusok/img/BoyerMoore_shift1.png b/Régebbi záróvizsga kidolgozások/2015/14.Haladó algoritmusok/img/BoyerMoore_shift1.png new file mode 100644 index 0000000..66b94ac Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/14.Haladó algoritmusok/img/BoyerMoore_shift1.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/14.Haladó algoritmusok/img/BoyerMoore_shift2.png b/Régebbi záróvizsga kidolgozások/2015/14.Haladó algoritmusok/img/BoyerMoore_shift2.png new file mode 100644 index 0000000..514f401 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/14.Haladó algoritmusok/img/BoyerMoore_shift2.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/14.Haladó algoritmusok/img/Huffman_fa.png b/Régebbi záróvizsga kidolgozások/2015/14.Haladó algoritmusok/img/Huffman_fa.png new file mode 100644 index 0000000..682a93c Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/14.Haladó algoritmusok/img/Huffman_fa.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/14.Haladó algoritmusok/img/KMP.jpg b/Régebbi záróvizsga kidolgozások/2015/14.Haladó algoritmusok/img/KMP.jpg new file mode 100644 index 0000000..c4ca0bc Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/14.Haladó algoritmusok/img/KMP.jpg differ diff --git a/Régebbi záróvizsga kidolgozások/2015/14.Haladó algoritmusok/img/KMP_initnext.jpg b/Régebbi záróvizsga kidolgozások/2015/14.Haladó algoritmusok/img/KMP_initnext.jpg new file mode 100644 index 0000000..9a7da44 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/14.Haladó algoritmusok/img/KMP_initnext.jpg differ diff --git a/Régebbi záróvizsga kidolgozások/2015/14.Haladó algoritmusok/img/KMP_sample.png b/Régebbi záróvizsga kidolgozások/2015/14.Haladó algoritmusok/img/KMP_sample.png new file mode 100644 index 0000000..80cf80a Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/14.Haladó algoritmusok/img/KMP_sample.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/14.Haladó algoritmusok/img/RK.jpg b/Régebbi záróvizsga kidolgozások/2015/14.Haladó algoritmusok/img/RK.jpg new file mode 100644 index 0000000..f913a3e Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/14.Haladó algoritmusok/img/RK.jpg differ diff --git a/Régebbi záróvizsga kidolgozások/2015/14.Haladó algoritmusok/img/RK_Horner.jpg b/Régebbi záróvizsga kidolgozások/2015/14.Haladó algoritmusok/img/RK_Horner.jpg new file mode 100644 index 0000000..e36aaab Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/14.Haladó algoritmusok/img/RK_Horner.jpg differ diff --git a/14.Haladó algoritmusok/tetel14.tex b/Régebbi záróvizsga kidolgozások/2015/14.Haladó algoritmusok/tetel14.tex similarity index 100% rename from 14.Haladó algoritmusok/tetel14.tex rename to Régebbi záróvizsga kidolgozások/2015/14.Haladó algoritmusok/tetel14.tex diff --git a/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/allapot.png b/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/allapot.png new file mode 100644 index 0000000..91c90d0 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/allapot.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/filo.png b/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/filo.png new file mode 100644 index 0000000..11eff34 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/filo.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/fogyaszto_szemafor.png b/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/fogyaszto_szemafor.png new file mode 100644 index 0000000..cc2eb9b Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/fogyaszto_szemafor.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/gyarto_szemafor.png b/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/gyarto_szemafor.png new file mode 100644 index 0000000..f845be9 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/gyarto_szemafor.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/iro.png b/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/iro.png new file mode 100644 index 0000000..8169214 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/iro.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/mutex.png b/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/mutex.png new file mode 100644 index 0000000..37fa144 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/mutex.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/ntfs.png b/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/ntfs.png new file mode 100644 index 0000000..5e0d87a Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/ntfs.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/ntfs2.png b/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/ntfs2.png new file mode 100644 index 0000000..85fbfbb Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/ntfs2.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/olvaso.png b/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/olvaso.png new file mode 100644 index 0000000..82df7cd Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/olvaso.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/pekvasarlo.png b/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/pekvasarlo.png new file mode 100644 index 0000000..e2c4b39 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/pekvasarlo.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/peterson.png b/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/peterson.png new file mode 100644 index 0000000..d1d1536 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/peterson.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/petersonhiba.png b/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/petersonhiba.png new file mode 100644 index 0000000..2e31a62 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/petersonhiba.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/szigoru.png b/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/szigoru.png new file mode 100644 index 0000000..79c12f8 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/img/szigoru.png differ diff --git a/15.Operációs rendszerek/tetel15.tex b/Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/tetel15.tex similarity index 100% rename from 15.Operációs rendszerek/tetel15.tex rename to Régebbi záróvizsga kidolgozások/2015/15.Operációs rendszerek/tetel15.tex diff --git a/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/adaptivfa.png b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/adaptivfa.png new file mode 100644 index 0000000..f9576e6 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/adaptivfa.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/alapsav.png b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/alapsav.png new file mode 100644 index 0000000..99af2a0 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/alapsav.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/aloha_csma.jpg b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/aloha_csma.jpg new file mode 100644 index 0000000..f1271c2 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/aloha_csma.jpg differ diff --git a/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/amplitudo_key.png b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/amplitudo_key.png new file mode 100644 index 0000000..25e2ce1 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/amplitudo_key.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/amplitudo_mod.png b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/amplitudo_mod.png new file mode 100644 index 0000000..7f1cbb7 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/amplitudo_mod.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/bitbeszuras.png b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/bitbeszuras.png new file mode 100644 index 0000000..de20306 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/bitbeszuras.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/csuszoablak.png b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/csuszoablak.png new file mode 100644 index 0000000..3152b6e Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/csuszoablak.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/egyszeru_aloha.png b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/egyszeru_aloha.png new file mode 100644 index 0000000..d50e7cf Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/egyszeru_aloha.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/egyszeru_bithiba.png b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/egyszeru_bithiba.png new file mode 100644 index 0000000..c77a889 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/egyszeru_bithiba.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/elektromagneses.png b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/elektromagneses.png new file mode 100644 index 0000000..f55a222 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/elektromagneses.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/fazis_key.png b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/fazis_key.png new file mode 100644 index 0000000..3dc5694 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/fazis_key.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/fazis_mod.png b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/fazis_mod.png new file mode 100644 index 0000000..c731a10 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/fazis_mod.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/frekvencia_key.png b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/frekvencia_key.png new file mode 100644 index 0000000..ff3b00f Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/frekvencia_key.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/frekvencia_mod.png b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/frekvencia_mod.png new file mode 100644 index 0000000..0fd23d1 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/frekvencia_mod.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/hamming1.png b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/hamming1.png new file mode 100644 index 0000000..e800a5c Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/hamming1.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/hamming2.png b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/hamming2.png new file mode 100644 index 0000000..3a5e406 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/hamming2.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/hamming3.png b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/hamming3.png new file mode 100644 index 0000000..e33be16 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/hamming3.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/hdlc_keret.png b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/hdlc_keret.png new file mode 100644 index 0000000..8f4b794 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/hdlc_keret.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/ip_fejresz.png b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/ip_fejresz.png new file mode 100644 index 0000000..2dad2fc Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/ip_fejresz.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/ip_spec_cimek.png b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/ip_spec_cimek.png new file mode 100644 index 0000000..b13a7b4 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/ip_spec_cimek.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/ipv6.png b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/ipv6.png new file mode 100644 index 0000000..2122e1e Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/ipv6.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/karakterbeszuras.png b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/karakterbeszuras.png new file mode 100644 index 0000000..6b6eec0 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/karakterbeszuras.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/karakterszamlalas.png b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/karakterszamlalas.png new file mode 100644 index 0000000..e015917 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/karakterszamlalas.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/paritasbit.png b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/paritasbit.png new file mode 100644 index 0000000..0eaf59c Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/paritasbit.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/ppp_keret.png b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/ppp_keret.png new file mode 100644 index 0000000..8ed35db Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/ppp_keret.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/rpc.png b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/rpc.png new file mode 100644 index 0000000..8ef2233 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/rpc.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/szelessav.png b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/szelessav.png new file mode 100644 index 0000000..fd3266b Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/szelessav.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/szinkronizacio.png b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/szinkronizacio.png new file mode 100644 index 0000000..41759ce Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/szinkronizacio.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/tcp_fejlec.png b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/tcp_fejlec.png new file mode 100644 index 0000000..9fc1c0b Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/img/tcp_fejlec.png differ diff --git a/16.Számítógépes hálózatok és Internet eszközök/tetel16.tex b/Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/tetel16.tex similarity index 100% rename from 16.Számítógépes hálózatok és Internet eszközök/tetel16.tex rename to Régebbi záróvizsga kidolgozások/2015/16.Számítógépes hálózatok és Internet eszközök/tetel16.tex diff --git a/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/atlatszosag.png b/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/atlatszosag.png new file mode 100644 index 0000000..150afe5 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/atlatszosag.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/clockspeed.png b/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/clockspeed.png new file mode 100644 index 0000000..56f0742 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/clockspeed.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/dht.png b/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/dht.png new file mode 100644 index 0000000..5bedba8 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/dht.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/dns.png b/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/dns.png new file mode 100644 index 0000000..de3a083 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/dns.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/hls_insert.png b/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/hls_insert.png new file mode 100644 index 0000000..2b8f98a Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/hls_insert.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/kolcskizar_elosztott.png b/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/kolcskizar_elosztott.png new file mode 100644 index 0000000..4ae18b6 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/kolcskizar_elosztott.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/kolcskizar_kozp.png b/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/kolcskizar_kozp.png new file mode 100644 index 0000000..3a5825a Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/kolcskizar_kozp.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/konz_okozati.png b/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/konz_okozati.png new file mode 100644 index 0000000..1678ea0 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/konz_okozati.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/konz_soros.png b/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/konz_soros.png new file mode 100644 index 0000000..ffd7369 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/konz_soros.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/nevter.png b/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/nevter.png new file mode 100644 index 0000000..aa85291 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/nevter.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/rpc.png b/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/rpc.png new file mode 100644 index 0000000..2a2f8cb Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/rpc.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/socket.png b/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/socket.png new file mode 100644 index 0000000..6781708 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/socket.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/zsarnok.png b/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/zsarnok.png new file mode 100644 index 0000000..3bc1924 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/img/zsarnok.png differ diff --git a/17.Osztott rendszerek/tetel17.tex b/Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/tetel17.tex similarity index 100% rename from 17.Osztott rendszerek/tetel17.tex rename to Régebbi záróvizsga kidolgozások/2015/17.Osztott rendszerek/tetel17.tex diff --git a/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/dekomp1.png b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/dekomp1.png new file mode 100644 index 0000000..1af661b Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/dekomp1.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/ek.png b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/ek.png new file mode 100644 index 0000000..568fef4 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/ek.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/ek1.png b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/ek1.png new file mode 100644 index 0000000..e19cfa5 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/ek1.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/ek2.png b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/ek2.png new file mode 100644 index 0000000..63c1132 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/ek2.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/ek3.png b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/ek3.png new file mode 100644 index 0000000..bdda02a Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/ek3.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/ek4.png b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/ek4.png new file mode 100644 index 0000000..4af4431 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/ek4.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/ek5.png b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/ek5.png new file mode 100644 index 0000000..0e8f4b1 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/ek5.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/ek6.png b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/ek6.png new file mode 100644 index 0000000..1702005 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/ek6.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/ek7.png b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/ek7.png new file mode 100644 index 0000000..068b8b1 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/ek7.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/ek8.png b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/ek8.png new file mode 100644 index 0000000..8b6b687 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/ek8.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/ek9.png b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/ek9.png new file mode 100644 index 0000000..a961ca2 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/ek9.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/null.png b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/null.png new file mode 100644 index 0000000..a994557 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/null.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/oo.png b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/oo.png new file mode 100644 index 0000000..c8d8e7a Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/oo.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/plsql1.png b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/plsql1.png new file mode 100644 index 0000000..17093ef Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/plsql1.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/psm1.png b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/psm1.png new file mode 100644 index 0000000..91a893c Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/psm1.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/psm2.png b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/psm2.png new file mode 100644 index 0000000..3c725a7 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/psm2.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/psm3.png b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/psm3.png new file mode 100644 index 0000000..b78bebf Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/psm3.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/relalg1.png b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/relalg1.png new file mode 100644 index 0000000..95316bf Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/relalg1.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/sql1.png b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/sql1.png new file mode 100644 index 0000000..a8e7809 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/sql1.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/sql2.png b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/sql2.png new file mode 100644 index 0000000..5c5e28a Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/img/sql2.png differ diff --git a/18.Adatbázisok tervezése és lekérdezése/tetel18.tex b/Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/tetel18.tex similarity index 100% rename from 18.Adatbázisok tervezése és lekérdezése/tetel18.tex rename to Régebbi záróvizsga kidolgozások/2015/18.Adatbázisok tervezése és lekérdezése/tetel18.tex diff --git a/Régebbi záróvizsga kidolgozások/2015/19.Adatbázisok optimalizálása és konkurencia kezelése/img/db_felepites.png b/Régebbi záróvizsga kidolgozások/2015/19.Adatbázisok optimalizálása és konkurencia kezelése/img/db_felepites.png new file mode 100644 index 0000000..bcca74e Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/19.Adatbázisok optimalizálása és konkurencia kezelése/img/db_felepites.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/19.Adatbázisok optimalizálása és konkurencia kezelése/img/deadlock.png b/Régebbi záróvizsga kidolgozások/2015/19.Adatbázisok optimalizálása és konkurencia kezelése/img/deadlock.png new file mode 100644 index 0000000..1114b9c Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/19.Adatbázisok optimalizálása és konkurencia kezelése/img/deadlock.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/19.Adatbázisok optimalizálása és konkurencia kezelése/img/kompmatrix.png b/Régebbi záróvizsga kidolgozások/2015/19.Adatbázisok optimalizálása és konkurencia kezelése/img/kompmatrix.png new file mode 100644 index 0000000..1114b9c Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/19.Adatbázisok optimalizálása és konkurencia kezelése/img/kompmatrix.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/19.Adatbázisok optimalizálása és konkurencia kezelése/img/querycompiling.png b/Régebbi záróvizsga kidolgozások/2015/19.Adatbázisok optimalizálása és konkurencia kezelése/img/querycompiling.png new file mode 100644 index 0000000..11ae31a Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/19.Adatbázisok optimalizálása és konkurencia kezelése/img/querycompiling.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/19.Adatbázisok optimalizálása és konkurencia kezelése/img/queryprocessing.png b/Régebbi záróvizsga kidolgozások/2015/19.Adatbázisok optimalizálása és konkurencia kezelése/img/queryprocessing.png new file mode 100644 index 0000000..86f9844 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/19.Adatbázisok optimalizálása és konkurencia kezelése/img/queryprocessing.png differ diff --git a/19.Adatbázisok optimalizálása és konkurencia kezelése/tetel19.tex b/Régebbi záróvizsga kidolgozások/2015/19.Adatbázisok optimalizálása és konkurencia kezelése/tetel19.tex similarity index 100% rename from 19.Adatbázisok optimalizálása és konkurencia kezelése/tetel19.tex rename to Régebbi záróvizsga kidolgozások/2015/19.Adatbázisok optimalizálása és konkurencia kezelése/tetel19.tex diff --git a/Régebbi záróvizsga kidolgozások/2015/2.Differenciál- és integrálszámítás/img/inflexio_sin.png b/Régebbi záróvizsga kidolgozások/2015/2.Differenciál- és integrálszámítás/img/inflexio_sin.png new file mode 100644 index 0000000..20e9652 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/2.Differenciál- és integrálszámítás/img/inflexio_sin.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/2.Differenciál- és integrálszámítás/img/inflexio_x2.png b/Régebbi záróvizsga kidolgozások/2015/2.Differenciál- és integrálszámítás/img/inflexio_x2.png new file mode 100644 index 0000000..1a25427 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/2.Differenciál- és integrálszámítás/img/inflexio_x2.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/2.Differenciál- és integrálszámítás/img/inflexio_x3.png b/Régebbi záróvizsga kidolgozások/2015/2.Differenciál- és integrálszámítás/img/inflexio_x3.png new file mode 100644 index 0000000..7a1b253 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/2.Differenciál- és integrálszámítás/img/inflexio_x3.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/2.Differenciál- és integrálszámítás/img/konvex.png b/Régebbi záróvizsga kidolgozások/2015/2.Differenciál- és integrálszámítás/img/konvex.png new file mode 100644 index 0000000..f8f7a91 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/2.Differenciál- és integrálszámítás/img/konvex.png differ diff --git a/2.Differenciál- és integrálszámítás/tetel2.tex b/Régebbi záróvizsga kidolgozások/2015/2.Differenciál- és integrálszámítás/tetel2.tex similarity index 100% rename from 2.Differenciál- és integrálszámítás/tetel2.tex rename to Régebbi záróvizsga kidolgozások/2015/2.Differenciál- és integrálszámítás/tetel2.tex diff --git a/Régebbi záróvizsga kidolgozások/2015/3.Numerikus módszerek/img/newton_pelda.png b/Régebbi záróvizsga kidolgozások/2015/3.Numerikus módszerek/img/newton_pelda.png new file mode 100644 index 0000000..29e2c1a Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/3.Numerikus módszerek/img/newton_pelda.png differ diff --git a/3.Numerikus módszerek/tetel3.tex b/Régebbi záróvizsga kidolgozások/2015/3.Numerikus módszerek/tetel3.tex similarity index 100% rename from 3.Numerikus módszerek/tetel3.tex rename to Régebbi záróvizsga kidolgozások/2015/3.Numerikus módszerek/tetel3.tex diff --git a/Régebbi záróvizsga kidolgozások/2015/4.Számelmélet, gráfok, kódoláselmélet/img/huffmann_split.png b/Régebbi záróvizsga kidolgozások/2015/4.Számelmélet, gráfok, kódoláselmélet/img/huffmann_split.png new file mode 100644 index 0000000..897e483 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/4.Számelmélet, gráfok, kódoláselmélet/img/huffmann_split.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/4.Számelmélet, gráfok, kódoláselmélet/img/shannon.png b/Régebbi záróvizsga kidolgozások/2015/4.Számelmélet, gráfok, kódoláselmélet/img/shannon.png new file mode 100644 index 0000000..202f04c Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/4.Számelmélet, gráfok, kódoláselmélet/img/shannon.png differ diff --git a/4.Számelmélet, gráfok, kódoláselmélet/tetel4.tex b/Régebbi záróvizsga kidolgozások/2015/4.Számelmélet, gráfok, kódoláselmélet/tetel4.tex similarity index 100% rename from 4.Számelmélet, gráfok, kódoláselmélet/tetel4.tex rename to Régebbi záróvizsga kidolgozások/2015/4.Számelmélet, gráfok, kódoláselmélet/tetel4.tex diff --git a/5.Valószínűségszámítási és statisztikai alapok/tetel5.tex b/Régebbi záróvizsga kidolgozások/2015/5.Valószínűségszámítási és statisztikai alapok/tetel5.tex similarity index 100% rename from 5.Valószínűségszámítási és statisztikai alapok/tetel5.tex rename to Régebbi záróvizsga kidolgozások/2015/5.Valószínűségszámítási és statisztikai alapok/tetel5.tex diff --git a/6.Mesterséges intelligencia/tetel6.tex b/Régebbi záróvizsga kidolgozások/2015/6.Mesterséges intelligencia/tetel6.tex similarity index 100% rename from 6.Mesterséges intelligencia/tetel6.tex rename to Régebbi záróvizsga kidolgozások/2015/6.Mesterséges intelligencia/tetel6.tex diff --git a/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/adattipus.png b/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/adattipus.png new file mode 100644 index 0000000..daf69a1 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/adattipus.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/adattipus_pelda.png b/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/adattipus_pelda.png new file mode 100644 index 0000000..d553681 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/adattipus_pelda.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/felsorolas_stuki.png b/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/felsorolas_stuki.png new file mode 100644 index 0000000..c7f70c7 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/felsorolas_stuki.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/felsorolo_halmaz.png b/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/felsorolo_halmaz.png new file mode 100644 index 0000000..599daff Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/felsorolo_halmaz.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/felsorolo_intervallum.png b/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/felsorolo_intervallum.png new file mode 100644 index 0000000..81496c0 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/felsorolo_intervallum.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/felsorolo_matrix.png b/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/felsorolo_matrix.png new file mode 100644 index 0000000..3f2531e Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/felsorolo_matrix.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/felsorolo_seqin.png b/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/felsorolo_seqin.png new file mode 100644 index 0000000..a3ec3ed Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/felsorolo_seqin.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/felsorolo_sorozat.png b/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/felsorolo_sorozat.png new file mode 100644 index 0000000..b75de78 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/felsorolo_sorozat.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/felsorolo_speci.png b/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/felsorolo_speci.png new file mode 100644 index 0000000..034ef97 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/felsorolo_speci.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/felsorolo_vektor.png b/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/felsorolo_vektor.png new file mode 100644 index 0000000..9af1766 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/felsorolo_vektor.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/stuki_alapszerk1.png b/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/stuki_alapszerk1.png new file mode 100644 index 0000000..4aac24d Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/stuki_alapszerk1.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/stuki_alapszerk2.png b/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/stuki_alapszerk2.png new file mode 100644 index 0000000..deaa556 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/stuki_alapszerk2.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/stuki_pelda.png b/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/stuki_pelda.png new file mode 100644 index 0000000..2bad659 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/7.Programozás/img/stuki_pelda.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/7.Programozás/progtetel_felsorolo.pdf b/Régebbi záróvizsga kidolgozások/2015/7.Programozás/progtetel_felsorolo.pdf new file mode 100644 index 0000000..55c4399 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/7.Programozás/progtetel_felsorolo.pdf differ diff --git a/7.Programozás/tetel7.tex b/Régebbi záróvizsga kidolgozások/2015/7.Programozás/tetel7.tex similarity index 100% rename from 7.Programozás/tetel7.tex rename to Régebbi záróvizsga kidolgozások/2015/7.Programozás/tetel7.tex diff --git a/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/Hasznalatieset.png b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/Hasznalatieset.png new file mode 100644 index 0000000..0f1999b Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/Hasznalatieset.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/Kompozicio2.png b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/Kompozicio2.png new file mode 100644 index 0000000..8797981 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/Kompozicio2.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/Objektum.png b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/Objektum.png new file mode 100644 index 0000000..f4f3dc5 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/Objektum.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/Plane.png b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/Plane.png new file mode 100644 index 0000000..e2409d3 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/Plane.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/Tevekenyseg2.png b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/Tevekenyseg2.png new file mode 100644 index 0000000..3505178 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/Tevekenyseg2.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/aggregacio.png b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/aggregacio.png new file mode 100644 index 0000000..a17c9ea Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/aggregacio.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/aggregacio2.png b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/aggregacio2.png new file mode 100644 index 0000000..670b1d5 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/aggregacio2.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/aktivacios_eletvonal.png b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/aktivacios_eletvonal.png new file mode 100644 index 0000000..e8048c9 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/aktivacios_eletvonal.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/asszociacio.png b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/asszociacio.png new file mode 100644 index 0000000..093e2f6 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/asszociacio.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/asszociacio2.png b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/asszociacio2.png new file mode 100644 index 0000000..c10b2d3 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/asszociacio2.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/eletvonal.png b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/eletvonal.png new file mode 100644 index 0000000..757ab46 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/eletvonal.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/evolucios.png b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/evolucios.png new file mode 100644 index 0000000..cb40931 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/evolucios.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/kompozicio.png b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/kompozicio.png new file mode 100644 index 0000000..581e96c Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/kompozicio.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/kovetelmenyleiras.png b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/kovetelmenyleiras.png new file mode 100644 index 0000000..b66cfcc Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/kovetelmenyleiras.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/nemfunkckov.png b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/nemfunkckov.png new file mode 100644 index 0000000..b53a8e9 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/nemfunkckov.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/oroklodes.png b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/oroklodes.png new file mode 100644 index 0000000..1d089c6 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/oroklodes.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/osztaly.png b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/osztaly.png new file mode 100644 index 0000000..ba90246 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/osztaly.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/spiral.png b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/spiral.png new file mode 100644 index 0000000..c057b2e Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/spiral.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/tevekenyseg.png b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/tevekenyseg.png new file mode 100644 index 0000000..fad830e Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/tevekenyseg.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/vizeses.png b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/vizeses.png new file mode 100644 index 0000000..e07427f Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/img/vizeses.png differ diff --git a/8.Programfejlesztési modellek/tetel8.tex b/Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/tetel8.tex similarity index 100% rename from 8.Programfejlesztési modellek/tetel8.tex rename to Régebbi záróvizsga kidolgozások/2015/8.Programfejlesztési modellek/tetel8.tex diff --git a/Régebbi záróvizsga kidolgozások/2015/9.Programok fordítása és végrehajtása/img/bajtkod_folyamatabra.png b/Régebbi záróvizsga kidolgozások/2015/9.Programok fordítása és végrehajtása/img/bajtkod_folyamatabra.png new file mode 100644 index 0000000..f34568a Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/9.Programok fordítása és végrehajtása/img/bajtkod_folyamatabra.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/9.Programok fordítása és végrehajtása/img/forditas_folyamatabra.png b/Régebbi záróvizsga kidolgozások/2015/9.Programok fordítása és végrehajtása/img/forditas_folyamatabra.png new file mode 100644 index 0000000..e8431d3 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/9.Programok fordítása és végrehajtása/img/forditas_folyamatabra.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/9.Programok fordítása és végrehajtása/img/forditas_teljes_folyamata.png b/Régebbi záróvizsga kidolgozások/2015/9.Programok fordítása és végrehajtása/img/forditas_teljes_folyamata.png new file mode 100644 index 0000000..a91645e Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/9.Programok fordítása és végrehajtása/img/forditas_teljes_folyamata.png differ diff --git a/Régebbi záróvizsga kidolgozások/2015/9.Programok fordítása és végrehajtása/img/interpretalas_folyamatabra.png b/Régebbi záróvizsga kidolgozások/2015/9.Programok fordítása és végrehajtása/img/interpretalas_folyamatabra.png new file mode 100644 index 0000000..54cb060 Binary files /dev/null and b/Régebbi záróvizsga kidolgozások/2015/9.Programok fordítása és végrehajtása/img/interpretalas_folyamatabra.png differ diff --git a/9.Programok fordítása és végrehajtása/tetel9.tex b/Régebbi záróvizsga kidolgozások/2015/9.Programok fordítása és végrehajtása/tetel9.tex similarity index 100% rename from 9.Programok fordítása és végrehajtása/tetel9.tex rename to Régebbi záróvizsga kidolgozások/2015/9.Programok fordítása és végrehajtása/tetel9.tex diff --git a/PTI BSc ZV tetelek 2015.pdf b/Régebbi záróvizsga kidolgozások/2015/PTI BSc ZV tetelek 2015.pdf similarity index 100% rename from PTI BSc ZV tetelek 2015.pdf rename to Régebbi záróvizsga kidolgozások/2015/PTI BSc ZV tetelek 2015.pdf diff --git a/Régebbi záróvizsga kidolgozások/2015/README.md b/Régebbi záróvizsga kidolgozások/2015/README.md new file mode 100644 index 0000000..4f540c7 --- /dev/null +++ b/Régebbi záróvizsga kidolgozások/2015/README.md @@ -0,0 +1,8 @@ +# ELTE IK - Bsc Záróvizsga 2015 tavaszi félév + +Ebben a projektben a 2015. év tavaszi félév záróvizsgájának tételsora került kidolgozásra. A tételek kellő részletességel a tananyag megértését szolgálják, + további ismeretanyagok szüksége nélküli szemléltben íródtak. Ennek tükrében néhány tétel olykor esetleg terjedelmesebb, mint ahogy azt a vizsgán prezentálni szükséges. + +A szerzők belegyezésével a tételkidolgozás szabadon felhasználható. + +Szerzők: **Ancsin Ádám**, **Bálint Márton**, **Dobreff András**, és **Fekete Dóra** \ No newline at end of file diff --git a/merge/minden.pdf b/Régebbi záróvizsga kidolgozások/2015/merge/minden.pdf similarity index 100% rename from merge/minden.pdf rename to Régebbi záróvizsga kidolgozások/2015/merge/minden.pdf diff --git a/merge/minden.tex b/Régebbi záróvizsga kidolgozások/2015/merge/minden.tex similarity index 100% rename from merge/minden.tex rename to Régebbi záróvizsga kidolgozások/2015/merge/minden.tex diff --git a/merge/tetel1.pdf b/Régebbi záróvizsga kidolgozások/2015/merge/tetel1.pdf similarity index 100% rename from merge/tetel1.pdf rename to Régebbi záróvizsga kidolgozások/2015/merge/tetel1.pdf diff --git a/merge/tetel10.pdf b/Régebbi záróvizsga kidolgozások/2015/merge/tetel10.pdf similarity index 100% rename from merge/tetel10.pdf rename to Régebbi záróvizsga kidolgozások/2015/merge/tetel10.pdf diff --git a/merge/tetel11.pdf b/Régebbi záróvizsga kidolgozások/2015/merge/tetel11.pdf similarity index 100% rename from merge/tetel11.pdf rename to Régebbi záróvizsga kidolgozások/2015/merge/tetel11.pdf diff --git a/merge/tetel12.pdf b/Régebbi záróvizsga kidolgozások/2015/merge/tetel12.pdf similarity index 100% rename from merge/tetel12.pdf rename to Régebbi záróvizsga kidolgozások/2015/merge/tetel12.pdf diff --git a/merge/tetel13.pdf b/Régebbi záróvizsga kidolgozások/2015/merge/tetel13.pdf similarity index 100% rename from merge/tetel13.pdf rename to Régebbi záróvizsga kidolgozások/2015/merge/tetel13.pdf diff --git a/merge/tetel14.pdf b/Régebbi záróvizsga kidolgozások/2015/merge/tetel14.pdf similarity index 100% rename from merge/tetel14.pdf rename to Régebbi záróvizsga kidolgozások/2015/merge/tetel14.pdf diff --git a/merge/tetel15.pdf b/Régebbi záróvizsga kidolgozások/2015/merge/tetel15.pdf similarity index 100% rename from merge/tetel15.pdf rename to Régebbi záróvizsga kidolgozások/2015/merge/tetel15.pdf diff --git a/merge/tetel16.pdf b/Régebbi záróvizsga kidolgozások/2015/merge/tetel16.pdf similarity index 100% rename from merge/tetel16.pdf rename to Régebbi záróvizsga kidolgozások/2015/merge/tetel16.pdf diff --git a/merge/tetel17.pdf b/Régebbi záróvizsga kidolgozások/2015/merge/tetel17.pdf similarity index 100% rename from merge/tetel17.pdf rename to Régebbi záróvizsga kidolgozások/2015/merge/tetel17.pdf diff --git a/merge/tetel18.pdf b/Régebbi záróvizsga kidolgozások/2015/merge/tetel18.pdf similarity index 100% rename from merge/tetel18.pdf rename to Régebbi záróvizsga kidolgozások/2015/merge/tetel18.pdf diff --git a/merge/tetel19.pdf b/Régebbi záróvizsga kidolgozások/2015/merge/tetel19.pdf similarity index 100% rename from merge/tetel19.pdf rename to Régebbi záróvizsga kidolgozások/2015/merge/tetel19.pdf diff --git a/merge/tetel2.pdf b/Régebbi záróvizsga kidolgozások/2015/merge/tetel2.pdf similarity index 100% rename from merge/tetel2.pdf rename to Régebbi záróvizsga kidolgozások/2015/merge/tetel2.pdf diff --git a/merge/tetel3.pdf b/Régebbi záróvizsga kidolgozások/2015/merge/tetel3.pdf similarity index 100% rename from merge/tetel3.pdf rename to Régebbi záróvizsga kidolgozások/2015/merge/tetel3.pdf diff --git a/merge/tetel4.pdf b/Régebbi záróvizsga kidolgozások/2015/merge/tetel4.pdf similarity index 100% rename from merge/tetel4.pdf rename to Régebbi záróvizsga kidolgozások/2015/merge/tetel4.pdf diff --git a/merge/tetel5.pdf b/Régebbi záróvizsga kidolgozások/2015/merge/tetel5.pdf similarity index 100% rename from merge/tetel5.pdf rename to Régebbi záróvizsga kidolgozások/2015/merge/tetel5.pdf diff --git a/merge/tetel6.pdf b/Régebbi záróvizsga kidolgozások/2015/merge/tetel6.pdf similarity index 100% rename from merge/tetel6.pdf rename to Régebbi záróvizsga kidolgozások/2015/merge/tetel6.pdf diff --git a/merge/tetel7.pdf b/Régebbi záróvizsga kidolgozások/2015/merge/tetel7.pdf similarity index 100% rename from merge/tetel7.pdf rename to Régebbi záróvizsga kidolgozások/2015/merge/tetel7.pdf diff --git a/merge/tetel8.pdf b/Régebbi záróvizsga kidolgozások/2015/merge/tetel8.pdf similarity index 100% rename from merge/tetel8.pdf rename to Régebbi záróvizsga kidolgozások/2015/merge/tetel8.pdf diff --git a/merge/tetel9.pdf b/Régebbi záróvizsga kidolgozások/2015/merge/tetel9.pdf similarity index 100% rename from merge/tetel9.pdf rename to Régebbi záróvizsga kidolgozások/2015/merge/tetel9.pdf diff --git a/sample.tex b/Régebbi záróvizsga kidolgozások/2015/sample.tex similarity index 100% rename from sample.tex rename to Régebbi záróvizsga kidolgozások/2015/sample.tex diff --git a/tetelvalasztas.tex b/Régebbi záróvizsga kidolgozások/2015/tetelvalasztas.tex similarity index 100% rename from tetelvalasztas.tex rename to Régebbi záróvizsga kidolgozások/2015/tetelvalasztas.tex diff --git a/TODO.md b/TODO.md new file mode 100644 index 0000000..6955fe7 --- /dev/null +++ b/TODO.md @@ -0,0 +1,55 @@ +# TODO + +[x] 1. Függvények határértéke, folytonossága + +[x] 2. Differenciál- és integrálszámítás + +[x] 3. Numerikus módszerek + +[x] 4. Számelmélet, gráfok, (Kódoláselmélet) + +[x] 5. Valószínűségszámítási és statisztikai alapok + +[x] 6. Mesterséges intelligencia + +[] 7. Programozás +* TODO: "Programozási tételekkel készült programok tesztelése" hiányzik! + +[x] 8. Objektumelvű modellezés + +[] 9. Objektumelvű tervezés +* TODO: "MV" és egyéb Architekturális minta hiányzik! + +[] 10. Programnyelvi alapok +* TODO: "Programozási nyelv szabályrendszere", "Alaptípusok ábrázolása", "Változók ábrázolása memóriában", "Programszerkezet" hiányzik! + +[] 11. Objektumelvű programozási nyelvek +* TODO: Kiegészítésre szorulhat! + +[x] 12. Formális nyelvek és automaták + +[x] 13. Számításelmélet (és Logika) + +[] 14. Alapvető algoritmusok +* TODO: "Függvények aszimptotikus viselkedése, algoritmusok hatékonysága" , "Rendezés lineáris időben", "Naiv adattömörítés", "Brute-force mintaillesztés" hiányzik! + +[] 15. Adatszerkezetek és adattípusok +* TODO: Erősen hiányos! + +[] 16. Haladó algoritmusok +* TODO: Erősen hiányos! + +[x] 17. Operációs rendszerek + +[] 18. Számítógépes hálózatok és Internet eszközök +* TODO: Néhány fogalom hiányozhat! + +[] 19. Osztott rendszerek és konkurens programozás +* TODO: Csak a "C" van kidolgozva a "2018"-as nem! + +[X] 20. Adatbázisok tervezése és lekérdezése + +[X] 21. Adatbázisok optimalizálása és konkurencia kezelése + +[] 22. Funkcionális programozás +* TODO: Erősen hiányos! diff --git a/sample.synctex.gz b/sample.synctex.gz deleted file mode 100644 index 1887b58..0000000 Binary files a/sample.synctex.gz and /dev/null differ diff --git a/tetelvalasztas.synctex.gz b/tetelvalasztas.synctex.gz deleted file mode 100644 index 5b7a4f1..0000000 Binary files a/tetelvalasztas.synctex.gz and /dev/null differ