Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Teoretyczne Podstawy Informatyki – Wykład 1 Poprawność algorytmów Osoba prowadząca wykład i ćwiczenia: dr inż. Marek Sawerwain Instytut Sterowania i Systemów Informatycznych Uniwersytet Zielonogórski e-mail :
[email protected] tel. (praca) : 68 328 2321, pok. 328a A-2, ul. prof. Z.Szafrana 2, 65-246 Zielona Góra
Ostatnia zmiana: 01 października 2013
V1.0a – 1/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Spis treści
1
Wprowadzenie Warunki zaliczenia Zakres tematyczny Plan wykładu Literatura
2
Poprawność algorytmów (programów) Problem jako algorytm Algorytm i program Dowodzenie częściowej poprawności Opis algorytmu (programu) Predykat charakterystyczny oraz asercja Najsłabszy warunek wstępny
3
Już za tydzień na wykładzie
V1.0a – 2/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Warunki zaliczenia
Warunki zaliczenia Wykład: kończy się egzaminem pisemnym obejmującym zagadnienia omawiane na wykładzie. Egzamin odbywa się podczas sesji zimowej. Ćwiczenia: w ramach ćwiczeń odbędą się trzy pisemne sprawdziany wiedzy, za każdy sprawdzian można uzyskać maksymalnie dziesięć punktów. Dodatkowo obowiązkiem każdego studenta będzie przedstawienie na tablicy pełnego rozwiązania trzech różnych zadań (z różnych działów) ze zbioru zadań dotyczących ćwiczeń z teoretycznych podstaw informatyki. Za niedopełnienie tego obowiązku całkowita liczba punktów zostanie pomniejszona o cztery za każde nierozwiązane zadanie.
L.Punków 0-19 20-22 23-24 25-26 27-28 29-30
Ocena ndst dst dst plus db db plus bdb
Tablica : Tabela punktów i ocen Nieobecności podczas sprawdzianu wiedzy muszą być usprawiedliwione.
V1.0a – 3/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Zakres tematyczny
Zakres tematyczny – Syllabus
(I) Wiadomości wstępne: algorytm i jego własności, notacja asymptotyczna. (II) Poprawność algorytmów: algorytm poprawny, poprawność częściowa, własność określoności obliczeń, własność stopu; dowodzenie poprawności częściowej, dowodzenie własności stopu. (III) Podstawy teorii automatów i języków: automaty skończone i wyrażenia regularne, gramatyki bezkontekstowe, automaty ze stosem i języki bezkontekstowe, własności języków bezkontekstowych. (IV) Prymitywne modele algorytmiczne. Teza Churcha–Turinga. Maszyna Turinga i jej warianty. Maszyna o dostępie swobodnym. Programy licznikowe. Maszyny niedeterministyczne.
V1.0a – 4/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Zakres tematyczny
Zakres tematyczny (V) Sprawność algorytmów. Miary efektywności algorytmów. Złożoność przestrzenna i czasowa. Złożoność pesymistyczna i średnia. Dolne i górne ograniczenie złożoności. Złożoność naturalna. Problemy algorytmicznie zamknięte i otwarte, luka algorytmiczna. Klasyfikacja problemów algorytmicznych. Problemy łatwo-rozwiązywalne i trudno-rozwiązywalne. Klasy problemów algorytmicznych: logarytmiczne, wielomianowe, NP, NP-zupełne i wykładnicze. Otwarte problemy związane z klasyfikacją problemów algorytmicznych. Dowodzenie NP-zupełności. Nierozwiązywalność i nieroztrzygalność.
(VI) Algorytmy współbieżne i probabilistyczne. Stała i rozszerzająca się współbieżność. Złożoność iloczynowa. Sieci - współbieżność o stałych połączeniach. Teza o obliczeniach równoległych. Klasa Nicka. Algorytmy RNC. Współbieżność rozproszona. Bezpieczeństwo i żywotność systemów współbieżnych. Algorytmy probabilistyczne niektórych konwencjonalnych problemów algorytmicznych. Probabilistyczne klasy złożoności.
(VII) Algorytmu kwantowe: Podstawowe informacje o modelu obliczeń kwantowych. Podstawowe algorytmy i protokoły obliczeń kwantowych. Problem Deutscha-Jozsy, alg. Shora faktoryzacji liczba, algorytm Grovera, teleportacja kwantowa. Obwody kwantowe. V1.0a – 5/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Plan wykładu
Plan wykładu – spotkania tydzień po tygodniu
(1) ⇒ Informacje o wykładzie, poprawność algorytmów ⇐ (2) Poprawność algorytmów – logika Hoarego
(3) Analiza złożoności kodu wysokiego i niskiego poziomu (4) Modele algorytmiczne – maszyny proste, obwody logiczne (5) Modele algorytmiczne – maszyna Turinga oraz rachunek lambda (6) Automaty – deterministyczne (7) Automaty – niedeterministyczne (8) Gramatyki – regularne i bezkontekstowe
V1.0a – 6/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Plan wykładu
Plan wykładu – spotkania tydzień po tygodniu
(9) Gramatyki i automaty ze stosem (10) Algorytmy równoległe (11) Klasy złożoności obliczeniowej (12) Pamięć logarytmiczna i wielomianowa (13) Problemy NP-zupełne (14) Wstęp do obliczeń kwantowych (15) Wybrane algorytmy kwantowe
V1.0a – 7/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Literatura
Literatura do wykładu oraz ćwiczeń 1
2 3 4
5
6 7
8
9
10
Piotr Dembiński, Jan Małusziński, Matematyczne metody definiowania języków programowania, WNT, 1981. David Gries, The Science of Programming, Springer-Verlag, 1981. Edgar Dijkstra, Umiejętność programowania, WNT, 1978. J.M. Brady, Informatyka teoretyczna w ujęciu programistycznym, WNT 1983. L. Banachowski, Antoni Kreczmar: Elementy analizy algorytmów, WNT 1982. Mordechai Ben-Ari, Logika matematyczna w informatyce, WNT, 2005. Bilski T., Chmiel K., Stokłosa J. Zbiór zadań ze złożoności obliczeniowej algorytmów, Wydawnictwo Politechniki Poznańskiej, 1992. Graham R.L., Knuth D.E., Patashnik O. Matematyka konkretna, PWN, 2002. Kenneth A.Ross, Charles R.B.Wright, Matematyka dyskretna, PWN, 2000. Cormen T.H., Leiserson C.E., Rivest R.L.: Wprowadzenie do algorytmów, WNT, 1997 (starsze i nowsze wydanie).
V1.0a – 8/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Literatura
Literatura do wykładu oraz ćwiczeń 11
Harel D., Rzecz o istocie informatyki, WNT, 2000.
12
Hopcroft J.E., Ullmann J.D., Wprowadzenie do teorii automatów, języków i obliczeń, PWN, 2003 (starsze i nowsze wydanie).
13
Papadimitriou C.H., Złożoność obliczeniowa, WNT 2002.
14
Stokłosa J., Zadania ze złożoności obliczeniowej algorytmów, Wydawnictwo Politechniki Poznańskiej, 1989.
15
Wróblewski P. Algorytmy, struktury danych i języki programowania, Helion, 1997.
16
Nilsson U., Małuszynski J., Logic, programming and Prolog, John Wiley & Sons, 1995, dostępna jako plik PDF, http://www.ida.liu.se/~ulfni/lpp/
Artykuł R. W. Floyda o niezmiennikach: R.W. Floyd, Assigning meanings to programs, Proceedings of the American Mathematical Society Symposia on Applied Mathematics, Vol. 19, pp. 19–31. 1967.
Artykuł autorstwa C.A.R. Hoarego: C.A.R. Hoare, An Axiomatic Basis for Computer Programming, Communications of the ACM, Vol. 12, No. 10, pp.576–583, 1969. V1.0a – 9/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Literatura
Materiały dodatkowe
Dodatkowe materiały związane z poprawnością algorytmów: 1
Logika Algorytmiczna, Przemysław Kobylański, wykład, Instytut Matematyki i Informatyki, Politechnika Wrocławska
2
Przedmiot „Semantyka i weryfikacja programów” z „Ważniaka” – http://wazniak.mimuw.edu.pl/index.php?title=Semantyka_i_ weryfikacja_programów
3
Formal Programming, Geoff Hamilton, wykład, http://www. computing.dcu.ie/~hamilton/teaching/CA648/index.html
Słowa kluczowe: 1
poprawność programów, problem stopu,
2
poprawność częściowa, poprawność całkowita.
V1.0a – 10/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Literatura
Plan wykładu – Poprawność algorytmów
1
Problem algorytmiczny 1 2 3
2
Czym jest algorytm? Przykłady problemów algorytmicznych Własności algorytmów
Poprawność algorytmów 1 2 3 4 5 6
Istniejące techniki dowodzenia poprawności Metoda Floyda Pojęcie asercji Predykat charakterystyczny Najsłabszy warunek wstępny (NWW) Przykłady NWW
V1.0a – 11/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Problem jako algorytm
Problem jako algorytm
Problem algorytmiczny Opis wszystkich poprawnych danych wejściowych
oraz
Opis oczekiwanych wyników jako funkcji danych wejściowych.
V1.0a – 12/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Problem jako algorytm
Przykłady problemów algorytmicznych
Sortowanie danych: DANE: tablica (a1 , a2 , . . . , an ) o n elementach typu porządkowego, SZUKANE: tablica o tych samych elementach ale uporządkowana np.: niemalejąco. Problem komiwojażera TSP (ang. Travelling Salesman Problem): DANE: n miast, odległości pomiędzy miastami (dij |i, j = 1, 2, . . . , n),
SZUKANE: trasa komiwojażera przez wszystkie miasta (ale tylko jedna wizyta w każdym mieście - permutacja miast) o najmniejszej sumie odległości.
V1.0a – 13/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Problem jako algorytm
Algorytm
Dowolne poprawne dane wejściowe
Algorytm – rozwiązanie problemu algorytmicznego
Oczekiwane wyniki
V1.0a – 14/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Problem jako algorytm
Własności algorytmu Operacje Podstawowe
Może korzystać z danych wejściowych
Każdy krok jednoznacznie i precyzyjnie zdefiniowany
Algorytm
Prowadzi do jednego lub więcej danych wyjściowych
Każdy możliwy przypadek przewidziany Wskazana własność ogólności Rozwiązanie zawsze osiągnięte w skończonej liczbie kroków V1.0a – 15/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Problem jako algorytm
Definicja poprawności algorytmicznej
Dowolne poprawne dane wejściowe warunek α
Algorytm – rozwiązanie problemu algorytmicznego warunek β
Algorytm nazywamy poprawnym, jeżeli dla dowolnych poprawnych danych wejściowych (spełniających warunek α) algorytm osiąga punkt końcowy i otrzymujemy poprawne wyniki (spełniających warunek β).
Oczekiwane wyniki
V1.0a – 16/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Algorytm i program
Trzy główne cechy algorytmu poprawnego
Algorytm poprawny
Częściowa poprawność
Własność określoności obliczeń
Własność stopu
V1.0a – 17/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Algorytm i program
Trzy główne cechy algorytmu poprawnego Częściowa poprawność: Algorytm nazywamy częściowo poprawnym, gdy prawdziwa jest następująca implikacja: jeżeli algorytm osiągnie koniec dla dowolnych poprawnych danych wejściowych, to dane wyjściowe będą spełniać warunek końcowy. Własność określoności obliczeń: Algorytm posiada powyższą własność, jeżeli dla dowolnych poprawnych danych wejściowych działanie algorytmu nie zostanie przerwane. Własność stopu: Algorytm posiada powyższą własność, jeżeli dla dowolnych poprawnych danych wejściowych algorytm nie będzie działał w nieskończoność.
V1.0a – 18/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Algorytm i program
Cechy dobrych algorytmów (programów)
Cechy dobrego algorytmu: 1
ścisły oraz zrozumiały opis algorytmu,
jednoznaczne określenie jakie obliczenia mają być zrealizowane. Cechy dobrego programu: 2
1
czytelny i dobrze udokumentowany kod źródłowy, efektywny, niezawodny,
2
przyjazny dla użytkownika,
3
poprawnie realizujący postawione zadanie, działający w rozsądnym czasie.
4
V1.0a – 19/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Algorytm i program
Techniki dowodzenia poprawności
Techniki oparte o logikę: 1
własność częściowej poprawności (logika pierwszego rzędu),
2
logika Hoare’go,
3
własność stopu (tzw. całkowita poprawność)
Inne podejścia: 1
inne logiki: temporalna (algorytmy i programy reaktywne), modalna,
2
specyfikacja algebraiczna,
3
wykorzystanie modeli abstrakcyjnych (programowanie obiektowe).
V1.0a – 20/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Dowodzenie częściowej poprawności
Metoda niezmienników Floyda Metoda postępowania: wyróżnić newralgiczne punkty w algorytmie, określić warunki (niezmienniki), jakie mają być spełnione w każdym wyróżnionym punkcie, udowodnić poprawność kolejnych warunków zakładając poprawność warunków poprzedzających. Podstawowe struktury sterujące: bezpośrednie następstwo, wybór warunkowy, iteracja ograniczona, iteracja warunkowo (nieograniczona), instrukcja skoku. V1.0a – 21/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Dowodzenie częściowej poprawności
Bezpośrednie następstwo
Instrukcja A Wykonanie instrukcji A, a następnie instrukcji B. Instrukcja B
V1.0a – 22/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Dowodzenie częściowej poprawności
Wybór warunkowy
T
W
N
Instrukcja A
Jeżeli spełniony jest warunek W to następuje wykonanie instrukcji A.
T
Instrukcja A
W
N
Instrukcja B
Jeżeli spełniony jest warunek W to następuje wykonanie instrukcji A, w przeciwnym wypadku następuje realizacja instrukcji B. V1.0a – 23/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Dowodzenie częściowej poprawności
Wybór warunkowy
Punkty newralgiczne instrukcji warunkowej dla niezmienników Floyda:
T
Instrukcja A
W
N
T
Instrukcja A
W
N
Instrukcja B
V1.0a – 24/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Dowodzenie częściowej poprawności
Iteracja ograniczona Zazwyczaj reprezentowana przez pętlę typu for: k = kmin
k > kmax N Instrukcja A
T Dla k od kmin do kmax wykonuj instrukcję A.
k++
V1.0a – 25/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Dowodzenie częściowej poprawności
Iteracja ograniczona Punkty newralgiczne iteracji ograniczonej dla niezmienników Floyda: k = kmin
k > kmax
T
N Instrukcja A
k++
V1.0a – 26/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Dowodzenie częściowej poprawności
Iteracja warunkowa (nieograniczona) Zazwyczaj reprezentowana przez pętle typu while lub repeat/until:
Instrukcja A N
W T
N
W
Instrukcja A T
Dopóki spełniony jest warunek W wykonuj instrukję A. Odpowiada to konstrukcji while W do A.
Wykonuj instrukję A dopóki nie zostanie spełniony warunek W . Odpowiada to konstrukcji repeat A until W.
V1.0a – 27/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Dowodzenie częściowej poprawności
Iteracja warunkowa (nieograniczona) Punkty newralgiczne iteracji warunkowej (nieograniczonej) dla niezmienników Floyda:
Instrukcja A N
W T
N
W
Instrukcja A T
V1.0a – 28/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Opis algorytmu (programu)
Suma ciągu elementów 1/5
Zadanie, jakże łatwe, opracować algorytm do obliczenia sumy elementów należących do pewnej sekwencji A i opracować (napisać) program w „ jakimś” języku: Krok 1: A = [0, 1, 2, 3, 4, 5, 6, . . . , m] Pn i=1 ai
Krok 2: S =
Krok 3: S:=0; for i:=1 to Length(A) do S=S+A[i];
Nasze zadanie to: A) opracować schemat blokowy, B) określić warunki, po realizacji poszczególnych instrukcji.
V1.0a – 29/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Opis algorytmu (programu)
Suma ciągu elementów 2/5 START
i←1
S←0
i>N
TAK
STOP
NIE
S ← S + ai
i←i+1
V1.0a – 30/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Opis algorytmu (programu)
Suma ciągu elementów 3/5 START n∈P i←1 n∈P ∧i=1 S←0
i>N
n∈P ∧i=1∧S =0 TAK
STOP
NIE
S ← S + ai
i←i+1
V1.0a – 31/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Opis algorytmu (programu)
Suma ciągu elementów 4/5 START n∈P i←1 n∈P ∧i=1 S←0
n∈P ∧i=1∧S =0 n∈P ∧i∈P ∧i≤n+1∧S
i>N TAK NIE
Pi−1
j=1
aj
n∈P ∧i∈P ∧i=n+1∧S = STOP
S ← S + ai
i←i+1
n∈P ∧i∈P ∧i≤n∧S =
Pi−1
n∈P ∧i∈P ∧i≤n∧S =
Pi
j=1
j=1
Pi−1
j=1
aj ; S =
Pn
j=1
aj
aj
aj
n∈P ∧i∈P ∧2≤i≤n+1∧S =
Pi−1
j=1
aj
V1.0a – 32/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Opis algorytmu (programu)
Suma ciągu elementów 5/5
Co można osiągnąć przedstawiając poszczególne warunki: 1 lepsze zrozumienie algorytmu, 2
co przekłada się na doskonalszy kod programu,
3
możliwość formalnego wnioskowania o poprawności algorytmu,
4
udowodnienie warunku stopu.
Przedstawiony schemat blokowy należy także taktować jako graf skierowany, wierzchołki to polecenia, natomiast krawędzie to możliwe przejścia pomiędzy poleceniami. Z taką definicją schematu blokowego wiąże się też pojęcie interpretacji, przedstawiając to nieformalnei jest nią odwzorowanie krawędzie do warunków przypisanych do tych krawędzi.
V1.0a – 33/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Opis algorytmu (programu)
Poprawność algorytmu dzielenia
START
x, y 1 q←0 r←x 2 q ←q+1 r ←r−y
TAK
r≥y NIE q, r
STOP
3
(1) α : x ≥ 0 ∧ y ≥ 0
(2) γ : x = q · y + r ∧ r ≥ 0 ∧ y ≥ 0 (3) β : x = q · y + r ∧ 0 ≤ r ≤ y Krok 1: γ 0 : x = q0 · y + r 0 ∧ r 0 ≥ 0 ∧ y 0 ≥ 0 Krok 2: x = (q + 1) · y + r − y = q · y + y + r − y = q·y +r Ostatecznie: r0 ≥ 0 ⇒ r − y ≥ 0 ⇒ r ≥ y
V1.0a – 34/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Opis algorytmu (programu)
Własność stopu
Dowodzenie własności stopu za pomocą metody liczników iteracji: begin p := c; while ι do begin K; p := p + 1; end
Definiujemy ograniczenie τ i dowodzimy, że przed każdą weryfikacją warunku ι spełniony jest niezmiennik p ≤ τ .
end
V1.0a – 35/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Opis algorytmu (programu)
Metoda liczników iteracji Metoda liczników iteracji dla algorytmu dzielenia: START
x, y 1 q←0 r←x 2 q ←q+1 r ←r−y
TAK
q, r
(2b) δ : q ≤ τ =
x y
(3) β : x = q · y + r ∧ 0 ≤ r ≤ y
r≥y NIE
(1) α : x ≥ 0 ∧ y ≥ 0
(2a) γ : x = q · y + r ∧ r ≥ 0 ∧ y ≥ 0
3
Ograniczenie: δ : x = q·y +r ⇒ x r x y − y ≤ y
x y
= q+
r y
⇒ q =
STOP
V1.0a – 36/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Opis algorytmu (programu)
Własność stopu
Dowodzenie własności stopu za pomocą metody malejących wielkości: begin i := w + 1 ; while ι do begin i := w; K (3 w := w − c) end
Istnieje wyrażenie w ≥ 0, które zmniejsza swą wartość w każdej iteracji, to wartość i również się obniża, ale wartość i jest ograniczone od dołu przez 0.
end
V1.0a – 37/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Opis algorytmu (programu)
Własność stopu Metoda malejących wielkości dla algorytmu dzielenia: START
x, y 1 q←0 r←x i←r+1 2 i←r q ←q+1 r ←r−y
TAK
(2a) γ : x = q · y + r ∧ r ≥ 0 ∧ y ≥ 0
(2b) δ : y > 0 ∧ (i = r + 1 ∨ i = r + y
r≥y NIE
(1) α : x ≥ 0 ∧ y ≥ 0
3
(3) β : x = q · y + r ∧ 0 ≤ r ≤ y
q, r
STOP V1.0a – 38/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Predykat charakterystyczny oraz asercja
Predykat charakterystyczny i stan programu Definicja stanu programu za [Ben Ari, 2005]: Stan programu Jeśli w programie występuje n zmiennych (x1 , x2 , . . . , xn ), to stan s określa krotka (v (x1 ), v (x2 ), . . . , v (xn )), gdzie v (xi ) jest wartością zmiennej xi . Predykat charakterystyczny Niech U będzie zbiorem wszystkich krotek utworzonych z elementów pewnej dziedziny (lub dziedzin). Niech U 0 ⊆ U. Predykat charakterystyczny PU 0 (v (x1 ), . . . , v (xn )) zbioru U 0 jest zdefiniowany tak, aby U 0 = {(v (x1 ), . . . , v (xn )) ∈ U|PU 0 (v (x1 ), . . . , v (xn )]}.
V1.0a – 39/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Predykat charakterystyczny oraz asercja
Predykat charakterystyczny Niech U = Z ⊗ Z , a U 0 ⊆ U niech będzie następującym zbiorem par liczb: ... ... (-2, -1) (-2, 0) (-2, 1) (-2, 2) (-2, 3) ... (-1, -1) (-1, 0) (-1, 1) (-1, 2) (-1, 3) ... (0, -1) (0, 0) (0, 1) (0, 2) (0, 3) ... (1, -1) (1, 0) (1, 1) (1, 2) (1, 3) ... (2, -1) (2, 0) (2, 1) (2, 2) (2, 3) ... Predykatem charakterystycznym zbioru U 0 jest (x1 = x1 ) ∧ (x2 ≤ 3) lub po uproszczeniu x2 ≤ 3. Program posiadający dwie zmienne całkowite może rozpocząć wykonywanie w jednym z 232 · 232 ≈ 1019 stanów na 32-bitowym komputerze! Dlatego, zamiast wnioskowania o stanach, konieczne jest wnioskowanie o predykatach charakterystycznych. V1.0a – 40/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Predykat charakterystyczny oraz asercja
Predykat charakterystyczny
Przykład związany z pojęciem predykatu charakterystycznego: Niech S będzie instrukcją programu o postaci x := 2 ∗ y + 1, która przekształca stan {(x, y )|true} w stan {(x, y )|x := 2y + 1}. Zakłada się, że zbiorem stanów początkowych jest {(x, y )|y ≤ 3}. Ponieważ (y ≤ 3) ⇒ (2y + 1 ≤ 7), wiec stan końcowy po wykonaniu instrukcji S będzie elementem zbioru {(x, y )|(x ≤ 7) ∧ (y ≤ 3)}. Mówi się, że S przekształca stan y ≤ 3 w (x ≤ 7) ∧ (y ≤ 3).
V1.0a – 41/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Predykat charakterystyczny oraz asercja
Asercja Definicja asercji – {p} code {q}
Asercją nazywamy trójkę {p} code {q}, gdzie code jest programem natomiast p i q, są formułami rachunku predykatów, nazywane warunkiem wstępnym oraz warunkiem końcowym. Asercja jest prawdziwa, co oznaczamy |= {p} code {q}, wtedy i tylko wtedy. gdy zachodzi warunek: jeśli program code rozpocznie wykonywanie w stanie spełniającym p oraz obliczenie code zakończy się, to obliczenie zakończy się w stanie spełniającym q. Jeśli |= {p} code {q}, to program S jest częściowo poprawny względem p i q.
Przykład asercji: |= {y ≤ 3} x := 2 · y + 1 {x ≤ 3 ∧ y ≤ 3} Asercje trywialne Dla każdego programu S oraz dowolnego q zachodzi |= {false}S{q}, gdyż nie istnieje stan spełniający false. Analogicznie dla dowolnego p oraz S zachodzi |= {p}S{true}. V1.0a – 42/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Predykat charakterystyczny oraz asercja
Warunek, ważna rzecz
Co wiadomo o takiej asercji: |= {y ≤ 3} x := 2 · y + 1 {x ≤ 3 ∧ y ≤ 3}
Warunek y ≤ 3 nie jest jedynym warunkiem wstępnym zapewniającym spełnienie warunku końcowego. Innym warunkiem wstępnym jest np.: y = 1 ∨ y = 3.
Warunek y = 1 ∨ y = 3 jest bardziej szczegółowy niż y ≤ 3 gdyż nie opisuje wszystkich stanów, z których obliczenie może przejść do stanu spełniającego warunek końcowy. Należy wybierać najmniej ograniczający warunek początkowy, tak aby stanem początkowym określonego obliczenia mogła być jak największa liczba stanów.
V1.0a – 43/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Najsłabszy warunek wstępny
Najsłabszy warunek wstępny – NWW Definicja określa najsłabszą formułę w rozpatrywanym w danym momencie zbiorze formuł: Formuła A jest słabsza od formuły B, jeśli B → A. Dla danego zbioru formuł {A1 , A2 , . . .} formuła Ai , jest najsłabszą formułą tego zbioru, jeśli Aj → Ai dla każdego j. Najsłabszy warunek wstępny jest bardzo przydatny w procesie określenia asercji dla instrukcji bądź zbioru instrukcji S. Niech będzie danych program S oraz formuła q, najsłabszym warunkiem wstępnym S oraz q nazwiemy taką formułę p dla której zachodzi |= {p}S{q}, co oznaczymy jako NWW(S, q). O czym mówi również poniższy lemat: |= {p}S{q} wtedy i tylko wtedy, gdy |= p → NWW(S, q) V1.0a – 44/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Najsłabszy warunek wstępny
Najsłabszy warunek wstępny – ilustracja Formuła y ≤ 3 jest słabsza od formuły y = 1 ∨ y = 3, która z kolei jest słabsza od formuły y = 1, tak wiec y ≤ 3 jest słabsza od y = 1.
y≤3 y =1∨y =3 y=0
y=1
y=2
y=3
Inne uwagi o predykatach w NWW: zawsze można wzmocnić poprzednik i osłabić następnik implikacji. Jeśli p ⇒ q, to również (p ∧ r ) ⇒ q oraz p ⇒ (q ∨ r ). Im słabszy predykat, tym więcej stanów go spełnia.
V1.0a – 45/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Najsłabszy warunek wstępny
Najsłabszy warunek wstępny – inne konstrukcje Pojęcie najsłabszego warunku wstępnego może być zastosowane do wyznaczania niezmienników albo warunków wstępnych. Pojęcie to może być stosowane do podstawowych instrukcji jak przypisanie, pętla while, instrukcja warunkowa. Przypisanie NWW(x := t, p(x)) = p(x){x ← t} Sekwencja instrukcji NWW(S1 ; S2 , q) = nww (S1 , nww (S2 , q)) Istnieje możliwość wykorzystania NWW do definicji niezmiennika: Warunek N nazwiemy niezmiennikiem wtedy i tylko wtedy, gdy NWW(S, N ) = N . V1.0a – 46/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Najsłabszy warunek wstępny
Najsłabszy warunek wstępny – inne konstrukcje NWW dla instrukcji warunkowej oraz pętli typu „dopóki”: O instrukcji warunkowej NWW(if W then S1 else S2 , q) = (W → NWW(S1 , q)) ∧ (¬W → NWW(S2 , q))
albo NWW(if W then S1 else S2 , q) = (W ∧ NWW(S1 , q)) ∨ (¬W ∧ NWW(S2 , q))
O pętli dopóki NWW(while W do S, q) = (¬W → q) ∧ (W → NWW(S; while W do S, q))
albo NWW(while W do S, q) = (¬W ∧ q) ∨ (W ∧ NWW(S; while W do S, q))
V1.0a – 47/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Najsłabszy warunek wstępny
NWW – przykłady Przykłady NWW: 1 2 3 4 5
NWW(x := 2 ∗ y + 1; x ≤ 7 ∧ y ≤ 3) = y ≤ 3, NWW(x := 2 ∗ y + 1; x ≤ 7) = y ≤ 3, NWW(x := 2 ∗ y + 1; x ≤ 9) = y ≤ 4, NWW(x := y + 2; x ≤ 7) = y ≤ 5,
NWW(y := y − 1; y ≥ 0) = y − 1 ≥ 0 ≡ y ≥ 1.
NWW dla dwóch instrukcji przypisania:
NWW(x := x + 1; y := y + 1; x < y ) =NWW(x := x + 1; NWW(y := y + 1; x < y )) =NWW(x := x + 1; x < y + 1) =x + 1 < y + 1 ≡ x < y
V1.0a – 48/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Najsłabszy warunek wstępny
NWW – przykłady Czego dotyczy poniższy przykład: NWW(x := x + a; y := y − 1; x = (b − y ) · a)
=NWW(x := x + a; NWW(y := y − 1; x = (b − y ) · a))
=NWW(x := x + a; x = (b − y + 1) · a)
=x + a = (b − y + 1) · a ≡ x = (b − y ) · a Drugi przykład: NWW(x := x + 1; y ≥ 0) = y ≥ 0 Instrukcja warunkowa: NWW(if y = 0 then x := 0 else x := y + 1; x = y ) =(y = 0 ⇒ NWW(x := 0; x = y )) ∧ (y 6= 0 ⇒ NWW(x := y + 1; x = y )) =(y = 0 ⇒ y = 0) ∧ (y 6= 0 ⇒ y + 1 = y )
=true ∧ (y 6= 0 ⇒ false) ≡¬(y 6= 0) ≡ y = 0
V1.0a – 49/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Najsłabszy warunek wstępny
NWW – przykłady NWW dla przykładowej pętli while, gdzie W oznacza while x > 0 do x := x − 1: NWW(W ; x = 0) =(¬(x > 0) ∧ (x = 0)) ∨ ((x > 0) ∧ NWW(x := x − 1; W ; x = 0)) ≡(x = 0) ∨ ((x > 0) ∧ NWW(x := x − 1; NWW(W ; x = 0)))
≡(x = 0) ∨ ((x > 0) ∧ NWW(W ; x = 0){x ← x − 1})
≡(x = 0) ∨ ((x > 0) ∧ [(x − 1 = 0) ∨ ((x − 1 > 0)∧ NWW(W ; x = 0){x ← x − 1}{x ← x − 1])
≡(x = 0) ∨ (x = 1) ∨ (x > 1 ∧ NWW(W ; x = 0){x ← x − 1}{x ← x − 1}) Końcowa postać: NWW(W ; x = 0) ≡(x = 0) ∨ (x = 1) ∨ (x = 2) ∨ . . .
≡x ≥ 0
V1.0a – 50/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
Najsłabszy warunek wstępny
Ważne własności NWW Twierdzenie o rozdzielaniu NWW: |= NWW(S, p) ∧ NWW(S, q) ⇔ NWW(S, p ∧ q) Wniosek, logika jednak działa albo „cudu nie ma”: |= NWW(S, p) ∧ NWW(S, ¬p) ⇔ NWW(S, false) Dualizm NWW: |= ¬NWW(S, ¬p) ⇒ NWW(S, p) Monotoniczność: (p ⇒ q) ⇒ (|= NWW(S, p) ⇒ NWW(S, q)) Dowody w [Ben Ari, 2005]. V1.0a – 51/ 52
Wprowadzenie
Poprawność algorytmów (programów)
Już za tydzień na wykładzie
A w następnym tygodniu między innymi
Tematy jakie zostaną poruszone na następnym wykładzie: 1
przydatność systemów formalnych,
2
logika (system) Hoarego (HL),
3
własności (HL),
4
reguły i poprawność częściowa,
5
poprawność całkowita,
6
przykład syntezy programu.
Dziękuje za uwagę!!! V1.0a – 52/ 52
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Teoretyczne Podstawy Informatyki – Wykład 2 Poprawność algorytmów – Logika Hoarego Osoba prowadząca wykład i ćwiczenia: dr inż. Marek Sawerwain Instytut Sterowania i Systemów Informatycznych Uniwersytet Zielonogórski e-mail :
[email protected] tel. (praca) : 68 328 2321, pok. 328a A-2, ul. prof. Z.Szafrana 2, 65-246 Zielona Góra
Ostatnia zmiana: 12 października 2012
V1.01 – 1/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Spis treści
1
Wstęp Plan wykładu – TPI Plan wykładu – Logika Hoarego Literatura
2
Logika Hoarego Reguły wnioskowania Reguły strukturalne Weryfikacja programów z pomocą HL Poprawność całkowita Synteza programów
3
Już za tydzień na wykładzie
V1.01 – 2/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Plan wykładu – TPI
Plan wykładu – spotkania tydzień po tygodniu
(1) Informacje o wykładzie, poprawność algorytmów (2) ⇒ Poprawność algorytmów – logika Hoarego ⇐ (3) Analiza złożoności kodu wysokiego i niskiego poziomu (4) Modele algorytmiczne – maszyny proste, obwody logiczne (5) Modele algorytmiczne – maszyna Turinga oraz rachunek lambda (6) Automaty – deterministyczne (7) Automaty – niedeterministyczne (8) Gramatyki – regularne i bezkontekstowe
V1.01 – 3/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Plan wykładu – TPI
Plan wykładu – spotkania tydzień po tygodniu
(9) Gramatyki i automaty ze stosem (10) Algorytmy równoległe (11) Klasy złożoności obliczeniowej (12) Pamięć logarytmiczna i wielomianowa (13) Problemy NP-zupełne (14) Wstęp do obliczeń kwantowych (15) Wybrane algorytmy kwantowe
V1.01 – 4/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Plan wykładu – Logika Hoarego
Plan wykładu – Poprawność algorytmów – Logika Hoarego
1
Informacje wstępne: 1 2 3
2
Logika Hoarego: 1 2 3
3
literatura, dodatkowe materiały, programy/pakiety związane z poprawnością algorytmów bądź programów. trójka Hoarego (asercja), reguły, własności HL.
Przykłady i podsumowanie 1 2 3
przykłady użycia poszczególnych reguł, przykłady weryfikacji programów za pomocą HL, synteza programu za pomocą HL.
V1.01 – 5/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Literatura
Literatura – Poprawność algorytmów/HL 1
David Gries, The Science of Programming, Springer-Verlag, 1981.
2
Edgar Dijkstra, Umiejętność programowania, WNT, 1978.
3
Mordechai Ben-Ari, Logika matematyczna w informatyce, WNT, 2005.
4
R. D. Tennent, Specifying Software, A hands-on intruduction, Cambridge University Press (New York), 2002.
Artykuł autorstwa C.A.R. Hoarego: C. A. R. Hoare, An Axiomatic Basis for Computer Programming, Communications of the ACM, Vol. 12, No. 10, pp.576–583, 1969. Artykuł autorstwa Krzysztofa R. Apta: Krzysztof R. Apt, Ten Years of Hoare’s Logic: A Survey Part 1, ACM Transactions on Programming Languages and Systems, Vol. 3, No. 4, October 1981. V1.01 – 6/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Literatura
Dodatkowe materiały
Inne przydatne materiały, które zostały wykorzystane do utworzenia tego wykładu: 1
Przemysław Kobylanski, Logika Algorytmiczna, wykład
2
Supratik Chakraborty, A Short Introduction to Hoare Logic, wykład
3
Anders Mmoller, Program Verification with Hoare Logic, http://www.brics.dk/~amoeller/talks/hoare.pdf
4
Jonathan Aldrich, Hoare Logic, http: //www.cs.cmu.edu/~aldrich/courses/413/slides/24-hoare.pdf
V1.01 – 7/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Literatura
Dodatkowe materiały Inne przydatne materiały, które zostały wykorzystane do utworzenia tego wykładu: 1
Daikon – http://groups.csail.mit.edu/pag/daikon/download/
2
Frama-C – http://frama-c.com/
3
VCC – http://vcc.codeplex.com/
4
Valigator – http://mtc.epfl.ch/software-tools/Aligator/Valigator/
5
KeY - Project – http://www.key-project.org/
6
Z3 Theorem Prover – http: //research.microsoft.com/en-us/um/redmond/projects/z3/
7
STP Constraint Solver – https://sites.google.com/site/stpfastprover/
8
CVC3 automatic theorem prover – http://www.cs.nyu.edu/acsys/cvc3/ V1.01 – 8/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Literatura
Krótko o systemie HL?
Logika Hoarego, to system formalny do wnioskowania o programach i asercjach, gdzie: program jest traktowany jako obiekt matematyczny, system wnioskowania o programie określa własności programu na podstawie własności podprogramów. Podstawowe odmiana systemu HL jest poprawna i względnie pełna i pozwala na przeprowadzenie dowodów częściowej poprawności przy pomocy podanych aksjomatów oraz reguł. System HL dostarcza aksjomaty oraz reguły wnioskowanie dla podstawowych programów pisanych w stylu strukturalnym. Naturalnie, istnieją rozszerzenia reguł HL, uwzględniające konstrukcje językowe inne niż podstawowe struktury sterujące jak instrukcja sekwencji, przypisania a także if oraz while np.: wskaźniki, procedury czy konstrukcje realizując współbieżność.
V1.01 – 9/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Literatura
Programy bywają podobne Dwa pytania? W jakim języku zostały napisany obydwie funkcje? Jaką wartość obliczają obydwie funkcje?
int f1 ( i nt n) { int k , rval ; k =0; r v a l =1;
int f2 ( int n) { int k , rval ; k =0; r v a l =1;
w h i l e ( k != n ) { k++; rval = 2 ∗ rval ; }
w h i l e ( k != n ) { k++; rval = 2 + rval ; }
return rval ; }
return rval ; }
Odpowiedzi: To zależy, może być C/C++, Java, C#, X10, Pike, ale ostatecznie funkcje były testowane w języku D. Funkcja f1 oblicza wartość 2n , natomiast f2 oblicza 1 + 2n.
V1.01 – 10/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Literatura
Programy bywają podobne Dwa pytania? W jakim języku zostały napisany obydwie funkcje? Jaką wartość obliczają obydwie funkcje?
int f1 ( i nt n) { int k , rval ; k =0; r v a l =1;
int f2 ( int n) { int k , rval ; k =0; r v a l =1;
w h i l e ( k != n ) { k++; rval = rval + rval ; }
w h i l e ( k != n ) { k++; rval = 2 + rval ; }
return rval ; }
return rval ; }
Odpowiedzi: To zależy, może być C/C++, Java, C#, X10, Pike, ale ostatecznie funkcje były testowane w języku D. Funkcja f1 oblicza wartość 2n , natomiast f2 oblicza 1 + 2n.
V1.01 – 11/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Logika Hoarego (HL) Czym jest logika Hoarego: Logika Hoarego albo logika Hoarego-Floyda, to system formalny wraz ze zbiorem reguł przeznaczony do wnioskowania o poprawności programów komputerowych. Formuła wyrażająca poprawność, tzw. trójka Hoarego (asercja): { P} S { Q } , gdzie S to program w danym języku programowania, a P i Q są formułami logiki (warunki), a także P to warunek wstępny, Q to warunek końcowy. Logika Hoarego (w podstawowej postaci) oferuje tylko częściową poprawność: Jeśli obliczenia programu S rozpoczynają się w stanie początkowym P, to jeśli się zakończą, to stan końcowy Q będzie spełniony. V1.01 – 12/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Przykłady trójek Hoarego
Czy takie trójki mogą istnieć? {true} x := 5 {x = 5} {x = y } x := x + 3 {x = y + 3} {x > −1} x := x ∗ 2 + 3 {x > 1} {x = a} if (x < 0) then x := −x {x = |x|} {false} x := 3 {x = 8} {x < 0} while(x! = 0) x := x − 1 { ? }
V1.01 – 13/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Przykłady trójek Hoarego
Która z poniższych asercji jest najlepsza? {x = 5}x := x ∗ 2{true} {x = 5}x := x ∗ 2{x > 0} {x = 5}x := x ∗ 2{x = 10||x = 5} {x = 5}x := x ∗ 2{x = 10}
V1.01 – 14/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
"Tyci/Tiny"język programowania Definicja podręcznego "tici/tiny"języka programowania Wyrażenia: E ::= N | V | E1 + E2 | E1 − E2 | E1 · E2 | E1 /E2 | ... Wyrażenia logiczne: B ::= True | False | E1 = E2 | E1 ≤ E2 | ... Polecenia: C::= V := E | C1 ; C2 | if B then C1 end if | if B then C1 else C2 end if | while B do C1 end while V1.01 – 15/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Reguły wnioskowania
Aksjomaty/reguły wnioskowania
Aksjomaty bądź reguły tego systemu można sprowadzić do następującej notacji podstawowej: {P} code {Q} Reguła przypisania ` {p(x){x ← t}} x := t {p(x)} Reguła złożenia sekwencyjnego ` {P} code1 {Q}, ` {Q} code2 {R} ` {P} code1 ; code2 {R}
V1.01 – 16/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Reguły wnioskowania
Przykłady
Przykład dla reguły przypisania: {x + z · y > 30} x := x + z · y ; {x > 30} Przykład dla reguły złożenia: {y + z > 4}y := y + z − 1; {y > 3} {y > 3}x := y + 2; {x > 5} {y + z > 4}y := y + z − 1; x := y + 2; {x > 5}
V1.01 – 17/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Reguły wnioskowania
Aksjomaty/reguły wnioskowania
Instrukcja if-else ` {P ∧ B}code1 {Q}, ` {P ∧ (¬B)}code2 {Q} ` {P} if B then code1 else code2 endif {Q} Instrukcja if-then ` {P ∧ B}code{Q}, ` {P ∧ (¬B)} ⇒ Q ` {P} if B then code endif {Q} Opis pętli ` {P ∧ B}code{P} ` {P} while {B} do code {(¬B) ∧ P}
V1.01 – 18/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Reguły wnioskowania
Przykłady reguł
Instrukcja warunkowa z blokiem „else”: {(y > 4) ∧ (z > 1)}y := y + z{y > 3} {(y > 4) ∧ ¬(z > 1)}y := y − 1{y > 3} {y > 4} if (z > 1) then y := y + z else y := y − 1 {y > 3}
Instrukcja pętli „while”: {(y = x + z) ∧ (z 6= 0)} x := x + 1; z := z − 1; {y = x + z} {y = x + z} while(z 6= 0) {x := x + 1; z := z − 1; }{(y = x + z) ∧ (z = 0)} oraz {(y = x + z) ∧ true} x := x + 1; z := z − 1; {y = x + z} {y = x + z} while(true) {x := x + 1; z := z − 1; }{(y = x + z) ∧ false}
V1.01 – 19/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Reguły wnioskowania
Uwagi do reguły pętli while
Pętla while ` {P ∧ B}code{P} ` {P} while {B} do code {(¬B) ∧ P} Dodatkowe dwie uwagi o pętli while: 1 2
P jest niezmiennikiem pętli, częściowa poprawność, 1
2
jeśli działanie pętli while nie kończy się, to wartość trójki Hoarego jest „pozornie” prawdziwa (ang. vacuous truth) i warunek dozoru nadal wskazuję prawdę, jeśli działanie pętli się kończy, to warunek (¬B ∧ P) musi być prawdziwy po zakończeniu działania pętli.
V1.01 – 20/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Reguły wnioskowania
Niezmienniki kodu (pętli)
Uwagi do niezmienników : 1
dla kodu pozbawionego pętli, niezmiennik jest bezpośrednio związany z kodem poszczególnych instrukcji,
2
niezmiennik pętli „zazwyczaj” jest związany z warunkiem końcowym,
3
jeśli są stosowane wartości indeksujące, to zazwyczaj stanowią część niezmiennika, należy zwrócić uwagę na sposób zmiany wartości indeksu, istotny jest też moment opuszczenia pętli, jeśli indeksacja jest związana z warunkiem dozoru pętli, to należy zwrócić uwagę na ilość lub warunek określający ostatni element.
4
V1.01 – 21/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Reguły wnioskowania
Aksjomaty/reguły wnioskowania Ostatnia reguła jaką będziemy stosować jest następująca: Reguła konsekwencji ` p1 → p
` {p}code{b} ` b → b1 ` {p1 }code{b1 }
W niektórych przypadkach łatwo wprowadzać dodatkowe reguły np.: dla pętli repeat S until W;, ponieważ można ten typ pętli zapisać w następujący sposób: S ; while ¬ W do S. Opis pętli repeat/until ` {P}code{Q} ` {Q ∧ ¬B}code{Q} ` {P}repeat code until B{Q ∧ B}
V1.01 – 22/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Reguły wnioskowania
Wzmocnienie poprzednika i osłabienie następnika
Reguła inferencyjna osłabiająca warunek w następniku i wzmacniająca poprzednik (reguła konsekwencji): P ⇒ P1 {P1 } code {P2 } P2 ⇒ Q {P} code {Q} Wyrażenia P ⇒ P1 oraz P2 ⇒ Q, to implikacje w logice predykatów.
(((y > 4) ∧ (z > 1)) ⇒ (y + z > 5)) {y + z > 5} y := y + z {y > 5} ((y > 5) ⇒ (y > 3)) {(y > 4) ∧ (z > 1)} y := y + z {y > 3}
V1.01 – 23/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Reguły strukturalne
Reguły strukturalne w HL Reguła koniunkcji {P1 }P{Q1 } {P2 }P{Q2 } {P1 ∧ P2 } P {Q1 ∧ Q2 } Reguła dysjunkcji {P1 }P{Q1 } {P2 }P{Q2 } {P1 ∨ P2 } P {Q1 ∨ Q2 } Kwantyfikator istnieje {P}P{Q} {∃vP} P {∃vQ} Kwantyfikator dla-każdego {P}P{Q} {∀vP} P {∀vQ} V1.01 – 24/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Reguły strukturalne
Poprawność i pełność HL
Wymaga to udowodnienia dwóch następujących twierdzień mających postać implikacji: Poprawność systemu HL Jeśli `HL {p}S{q}, to |= {p}S{q}. oraz drugiej implikacji Pełność systemu HL Jeśli |= {p}S{q}, to `HL {p}S{q}. Szczegóły i dalszy komentarz w [Ben-Ari, 2005].
V1.01 – 25/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Weryfikacja programów z pomocą HL
Formalna weryfikacja programów Program P obliczający iloczyn dwóch liczba całkowitych: {true } x :=0; {x = 0} y :=b ; {x = 0 ∧ y = b} w h i l e y 6= 0 do b e g i n {x = (b − y )a} x := x+a ; y := y− 1 ; end ; {x = a · b} Udowodnić następujące twierdzenie: ` {true}P{x = a · b}. V1.01 – 26/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Weryfikacja programów z pomocą HL
Formalna weryfikacja programów – iloczyn dwóch liczb Reguła przypisania generuje {0 = 0}x := 0{x = 0}, a po zastosowaniu reg. konsekwencji oraz z przesłanki true → (0 = 0), otrzymuje się {true}x := 0{x = 0}. Podobnie należy postąpić dla drugiej linii: {x = 0}y := b{(x = 0) ∧ (y = b)}. Druga część dowodu jest związana ze niezmiennikiem, niech p oznacza wyrażenie x = (b − y ) · a. Wiedząc, że p jest niezmiennikiem, czyli {p}x := x + a; y := y − 1; {p}, co łatwo sprawdzić: p : x = (b − y ) · a { ? } x := x+a ; y := y− 1 ; { p } x + a = (b − (y − 1)) · a x + a = (b − y + 1) · a x + a = ab − ay + a x = ab − ay p : x = (b − y ) · a
możliwe jest wzmocnienie warunku wstępnego: {p ∧ y 6= 0}x := x + a; y := y − 1; {p} V1.01 – 27/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Weryfikacja programów z pomocą HL
Formalna weryfikacja programów – iloczyn dwóch liczb
Wzmocnie umożliwia na następujący zapis: {p} w h i l e y 6= 0 do b e g i n {x = (b − y )a} x := x+a ; y := y− 1 ; end ; {p ∧ ¬(y 6= 0)}
Warunek końcowy pętli wolno również zapisać jako p ∧ (y = 0). Wykorzystując logikę predykatów oraz reguły konsekwencji, można ostatecznie wyprowadzić x = a · b, co stanowi warunek końcowy programu P.
V1.01 – 28/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Weryfikacja programów z pomocą HL
Formalna weryfikacja programów – suma elementów tablicy
Krótki kod obliczający sumę elementów tablicy A o wielkości N: { N≥0 } j := 0 ; s := 0 ; w h i l e ( j < N) do begin s := s + A [ j ] ; j := j + 1 ; end P { s = ( i | 0≤i≤N A[i] ) }
V1.01 – 29/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Weryfikacja programów z pomocą HL
Formalna weryfikacja programów – suma elementów tablicy Poprawność niezmiennika: P {0 ≤ j ≤ N ∧ s = ( i |0≤i
Pozostała część dowodu: P (0 ≤ j ≤ N ∧ s = ( i |0≤i
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Weryfikacja programów z pomocą HL
Formalna weryfikacja programów – suma elementów tablicy
Związek pomiędzy niezmiennikiem, warunkiem opuszczenia pętli i warunkiem końcowym: P P 0 ≤ j ≤ N ∧ s = ( i |0≤i
V1.01 – 31/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Weryfikacja programów z pomocą HL
Formalna weryfikacja programów – x! Obliczenia wartości funkcji silnia z x: { s i l n i a z x} { x ≥ 0 ∧ x = x0 } y := 1 ; z := 0 ; w h i l e z 6= x do begin z := z + 1 ; y := y ∗ z ; end { y = x! }
V1.01 – 32/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Weryfikacja programów z pomocą HL
Formalna weryfikacja programów – x! Obliczenia wartości funkcji silnia z x, poszczególne etapy weryfikacji: { x ≥ 0 ∧ x = x0 } { 1 = 0! ∧ x = x0 } y := 1 ; { y = 0! ∧ x = x0 } z := 0 ; { y = z! ∧ x = x0 ∧ z ≥ 0 } w h i l e z 6= x do begin { y = z! ∧ x = x0 ∧ z ≥ 0 ∧ z 6= x } { y (z + 1) = (z + 1)! ∧ x = x0 ∧ z + 1 ≥ 0 } z := z + 1 ; { y · z = z! ∧ x = x0 ∧ z ≥ 0 } y := y ∗ z ; { y = z! ∧ x = x0 ∧ z ≥ 0 } end { y = z! ∧ x = x0 ∧ z ≥ 0 ∧ ¬(z 6= x) } { y = x! }
V1.01 – 33/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Weryfikacja programów z pomocą HL
Formalna weryfikacja programów Algorytm dzielenia za pracą [Hoare, 1969]: 1 true ⊃ x = x + y · 0 2 x = x + y · 0{r := x}x = r + y · 0 3 x = r + y · 0{q := 0}x = r + y · q 4 true{r := x}x = r + y · 0 5 true{r := x; q := 0; }x = r + y · q 6 x = r + y · q ∧ y ≤ r ⊃ x = (r − y ) + y · (1 + q) 7 x = (r − y ) + y · (1 + q){r := r − y }x = r + y · (1 + q) 8 x = r + y · (1 + q){q := 1 + q}x = r + y · q 9 x = (r − y ) + y · (1 + q){r := r − y ; q := 1 + q}x = r + y · q 10 x = r + y · q ∧ y ≤ r {r := r − y ; q := 1 + q}x = r + y · q 11 x = r + y · q{while y ≤ r do begin r := r − y ; q := 1 + q; end} ¬y ≤ r ∧ x = r + y · q 12 true {((r := x; q := 0); while y ≤ r do begin r := r − y ; q := 1 + q; end}¬y ≤ r ∧ x = r + y · q
V1.01 – 34/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Poprawność całkowita
Poprawność całkowita Udowodnić poprawność całkowitą dla programu P mnożenia dwóch liczb. Aby wykazać własność poprawności całkowitej dla pętli typu while, należy znaleźć funkcję, której wartość zmniejsza się każdorazowo po wykonaniu treści pętli i wartość ta ma dolne ograniczenie. W programie P funkcją malejąca z każdym „obrotem” pętli jest reprezentowana przez zmienna y . Warunek y ≥ 0 należy dodać do niezmiennika, i stanowi on dolne ograniczenie poszukiwanej funkcji. Warunek początkowy b ≥ 0 oraz wykonanie dwóch początkowych instrukcji nadal zachodzi y ≥ 0. Łatwo też pokazać iż dodanie y ≥ 0 do niezmiennika nie zmienia jego prawdziwości:
{(x = (b − y ) · a) ∧ y ≥ 0 ∧ y = 6 0} x := x + a ; y := y − 1 ; {(x = (b − y ) · a) ∧ y ≥ 0} Poszukiwanie funkcji o dolnym ograniczenia, można zastosować dla każdego programu, w którym uda się wskazać zbiór dobrze uporządkowany.
V1.01 – 35/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Synteza programów
Wartość całkowita pierwiastka kwadratowego
Program wyznaczający całkowitą część wartości pierwiastka kwadratowego: {n ≥ 0} r t :=0; sqr :=1; w h i l e s q r ≤ n do begin r t := r t +1; s q r := s q r + 2 · r t + 1 end {rt 2 ≤ n ∧ n < (rt + 1)2 }
V1.01 – 36/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Synteza programów
Podejście pierwsze – 1/2 Bezpośrednie, pętla posłuży do obliczania szukanej wartości {0 ≤ a} x :=? w h i l e B( x , a ) do begin x :=? end 2 {0 ≤ x 2 ≤ a < (x + 1) } Niech p oznacza niezmiennik pętli 0 ≤ x 2 ≤ a, naturalnie dla warunku wstępnego 0 ≤ a, niezmiennik jest spełniony przed pętlą while, jeśli x:=0;. Warunkiem końcowym pętli będzie p ∧ ¬B(x, a) co oznacza iż B(x, a) musi zostać tak dobrane aby spełniony był warunek końcowy np.: niech ¬B(x, a) jest reprezentowane przez a < (x + 1)2 . A przekłada się to na fakt iż B(x, a) jest reprezentowane przez formułę (x + 1) · (x + 1) ≤ a. To pozwala na bardzo proste rozwiązanie, wystarczy, począwszy od zera zwiększać wartość x o jedność aby spełnić, niezmiennik oraz warunek dozoru pętli: V1.01 – 37/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Synteza programów
Podejście pierwsze – 2/2 {0 ≤ a} x :=0 w h i l e (x + 1) · (x + 1) ≤ a do begin {γ : 0 ≤ x 2 ≤ a} x := x+1 end 2 {0 ≤ x 2 ≤ a < (x + 1) } Poprawność niezmiennika {p ∧ B}S{p} 2
{0 ≤ x 2 ≤ a ∧ (x + 1) ≤ a}x := x + 1; {0 ≤ x 2 ≤ a} Reguła przypisania: 2
{0 ≤ (x + 1) ≤ a}x := x + 1; {0 ≤ x 2 ≤ a} A ostatecznie: 2 2 {0 ≤ x 2 ≤ a ∧ (x + 1) ≤ a} ⇒ {0 ≤ (x + 1) ≤ a} V1.01 – 38/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Synteza programów
Podejście drugie Inna postać niezmiennika: 0 ≤ x2 ≤ a < y2 Ponieważ pętla może się zakończyć, gdy y=x+1, niezmiennik będzie spełniony gdy y jest zawsze większy od x, naturalni wielkość większa a + 1 ze względu na to iż liczymy pierwiastek naturalnie nie ma sensu. Wobec tego wartość początkowa y to a + 1, a nowy niezmiennik przyjmuje postać:
{(0 ≤ x 2 ≤ a < y 2 ) ∧ (x < y ≤ a + 1)} Szkic początkowy programu: {0 ≤ a} x :=0 ; y := a +1; w h i l e y <> x+1 do begin {(0 ≤ x 2 ≤ a < y 2 ) ∧ (x < y ≤ a + 1)} ⇒ tu brakuje programu ⇐ end 2 {0 ≤ x 2 ≤ a < (x + 1) } V1.01 – 39/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Synteza programów
Podejście drugie – przykład
Niech a = 14, początkowe wartości, to x = 0 oraz y = 15. Pętla programu powinna się zakończyć gdy x = 3 oraz y = x + 1 = 4, co oznacza że 0 ≤ 9 ≤ 14 < 16. Zwiększenie wartości x bądź zmniejszenie wielkości y , zapewnia poprawność niezmiennika 0 ≤ x 2 ≤ a < y 2 . Jednak zamiast operacji zmniejszenia bądź zwiększenia wartości można wybrać wartość środkową: (x + y )/2 = (0 + 15)/2 = 7 (dzielenie całkowite z obcięciem). Należy otrzymaną wielkość przypisać do zmiennej x albo y dbając oto aby niezmiennik był prawidłowy. Ponieważ w podanym przypadku a = 14 < 49 = 7 · 7, to zmiana zmiennej y na 7 powoduje iż niezmiennik pozostaje prawdziwy. W kolejnej iteracji (x +y )/2 = (0+7)/2 = 3 oraz 3·3 = 9 < 14 = a, utrzymanie prawdziwości wymaga zmiany zmiennej x. Po kolejnych dwóch iteracjach otrzymuje się x = 3, y = 4 = x + 1, co pozwala na zakończenie pętli.
V1.01 – 40/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Synteza programów
Podejście drugie – synteza Szkic pętli uwzględniający wnioski z przykładu: {p ∧ (y 6= x + 1)} z := ( x+y ) d i v 2 ; {p ∧ (y 6= x + 1) ∧ (z = b(x + y )/2)c} i f W( x , y , z ) t h e n { p { x ← z }} x := z ; else { p { y ← z }} y := z ; {p}
Zmienna z reprezentuje wybraną wartość spełniającą niezmiennik, wyrażenie W (x, y , z) reprezentuje wyrażenie logiczne tak dobrane aby spełnione były reguły przypisania oraz następujące zależności: (p ∧ (y 6= x + 1) ∧ (z = b(x + y )/2)c ∧ W (x, y , z)) ⇒ p{x ← z} oraz (p ∧ (y 6= x + 1) ∧ (z = b(x + y )/2)c ∧ ¬W (x, y , z)) ⇒ p{y ← z}V1.01 – 41/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Synteza programów
Podejście drugie – synteza Szkic pętli uwzględniający wnioski z przykładu: {p ∧ (y 6= x + 1)} z := ( x+y ) d i v 2 ; {p ∧ (y 6= x + 1) ∧ (z = b(x + y )/2)c} i f W( x , y , z ) t h e n { p { x ← z }} x := z ; else { p { y ← z }} y := z ; {p}
Następniki implikacji są następujące:
p{x ← z} ≡ (0 ≤ z 2 ≤ a < y 2 ) ∧ (z < y ≤ a + 1) oraz
p{y ← z} ≡ (0 ≤ x 2 ≤ a < z 2 ) ∧ (x < z ≤ a + 1).
Jako że składnikiem poprzednika implikacji jest p, gdzie znajduje się wyrażenie 0 ≤ x 2 ≤ a < y 2 , to prawdziwe będą także pierwsze składniki koniunkcji wyrażeń p{x ← z} oraz p{y ← z}, gdy za warunek W (x, y , z) przyjmie się wyrażenie z 2 ≤ a. V1.01 – 42/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
Synteza programów
Podejście drugie – synteza Druga część wyrażeń p{x ← z} oraz p{y ← z} także jest prawdziwa. Z drugiej części p, z warunku x < y ≤ a + 1 oraz z = b(x + y )/2c, wynika z < y ≤ a + 1. Podobnie dla x < y ≤ a + 1 oraz z = b(x + y )/2c, wynika x < z ≤ a + 1, jeśli naturalnie y 6= x + 1, co jest zapewnione gdyż jest to część poprzednika implikacji. {0 ≤ n} x : = 0 ; y := a +1; w h i l e y <> x+1 do begin {0 ≤ x 2 ≤ a < y 2 ∧ x < y ≤ a + 1} z :=( x+y ) d i v 2 ; i f z ∗ z <= a t h e n x := z else y := z ; end ; {0 ≤ x 2 ≤ a < (x + 1)2 }
V1.01 – 43/ 44
Wstęp
Logika Hoarego
Już za tydzień na wykładzie
A w następnym tygodniu między innymi
1
Złożoność obliczeniowa
2
Notacja asymptotyczna
3
Relacje rekurencyjne
4
Podstawowe klasy złożoności
5
Złożoność obliczeniowa dla kodu niskiego poziomu
6
Złożoność obliczeniowa dla kodu wysokiego poziomu
Dziękuje za uwagę!!!
V1.01 – 44/ 44
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Teoretyczne Podstawy Informatyki – Wykład 3 Analiza złożoności kodu wysokiego i niskiego poziomu Osoba prowadząca wykład i ćwiczenia: dr inż. Marek Sawerwain Instytut Sterowania i Systemów Informatycznych Uniwersytet Zielonogórski e-mail :
[email protected] tel. (praca) : 68 328 2321, pok. 328a A-2, ul. prof. Z.Szafrana 2, 65-246 Zielona Góra
Ostatnia zmiana: 24 października 2012
V1.0 – 1/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Spis treści 1
Wprowadzenie Plan wykładu
2
Algorytmy Przykłady problemów
3
Operacje na sumach Operacje na sumach Przykłady
4
Notacja asymptotyczna Notacja asymptotyczna
5
Z.O. L/H – przykłady Złożoność dla programu niskiego poziomu Złożoność dla programów oraz algorytmów
6
Już za tydzień na wykładzie
V1.0 – 2/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Plan wykładu
Plan wykładu – spotkania tydzień po tygodniu
(1) Informacje o wykładzie, poprawność algorytmów (2) Poprawność algorytmów – logika Hoarego (3) ⇒ Analiza złożoności kodu wysokiego i niskiego poziomu ⇐ (4) Modele algorytmiczne – maszyny proste, obwody logiczne
(5) Modele algorytmiczne – maszyna Turinga oraz rachunek lambda (6) Automaty – deterministyczne (7) Automaty – niedeterministyczne (8) Gramatyki – regularne i bezkontekstowe
V1.0 – 3/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Plan wykładu
Plan wykładu – spotkania tydzień po tygodniu
(9) Gramatyki i automaty ze stosem (10) Algorytmy równoległe (11) Klasy złożoności obliczeniowej (12) Pamięć logarytmiczna i wielomianowa (13) Problemy NP-zupełne (14) Wstęp do obliczeń kwantowych (15) Wybrane algorytmy kwantowe
V1.0 – 4/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Plan wykładu
Plan wykładu
1
Wprowadzenie 1 2 3
2
Operacje na sumach, notacja asymptotyczna 1 2 3 4
3
literatura związane bezpośrednią z tematyką wykładu, kiedy algorytm można określać jako dobry, podstawowe klasy złożoności podstawowe wzory technika zaburzania notacja asymptotyczna przykłady
Złożoność obliczeniowa 1 2
kod niskiego poziomu kod wysokiego poziomu
V1.0 – 5/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Plan wykładu
Literatura do wykładu oraz ćwiczeń
Materiały wykorzystane podczas tworzenia tego wykładu: 1
Materiały do przedmiotów prezentowanych na „Ważniaku” – http://wazniak.mimuw.edu.pl/
2
Przydatne materiały do TPI – http://ux.ap.krakow.pl/~tpi/
3
Papadimitriou C.H., Złożoność obliczeniowa, WNT 2002, nowsze wydanie Helion, wrzesień 2012.
4
Harel D., Rzecz o istocie informatyki, WNT, 2000.
V1.0 – 6/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Dobry algorytm Pożądane własności algorytmów: (I) Poprawność algorytmiczna – własność oczekiwana od każdego algorytmu. (II) Kryteria wyboru algorytmu spośród algorytmów poprawnych: (a) konieczność wykorzystania możliwie jak najmniejszej ilości pamięci operacyjnej, (b) czas wykonywania możliwie jak najkrótszy.
Porównywanie czasu działania algorytmów wymaga wzięcia pod uwagę następujących obszarów: (a) specyfika problemu algorytmicznego, (b) konfiguracja sprzętu komputerowego, (c) wybór języka programowania, (d) wybór kompilatora, (e) sprzętowe warunki wykonywania programu (liczba procesów wykonywanych "w tle", temperatura procesora itp.). V1.0 – 7/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Złożoność jako funkcja rozmiaru problemu
Czas pracy algorytmu zależy od rozmiaru zadania. Przykłady zadań o rozmiarze n: 1
znaleźć najmniejszą wartość w tablicy n liczb całkowitych,
2 3
rozwiązać układ n równań liniowych AX = B na n niewiadomych, Pn wynaczyć wartość wielomianu Pn (x) = k=0 ak x k dla wybranej wartości x,
4
znajdź minimalne drzewo rozpinające graf o n wierzchołkach.
Jeżeli trudno jest wskazać wprost rozmiar zadania to n może być długością kodu danych zadania na komputerze.
V1.0 – 8/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Podstawowy podział na klasy złożoności EXPSPACE EXPTIME PSPACE PTIME LOGSPACE LOGTIME
Twierdzenie Następujące uporządkowanie jest prawdziwe w sensie notacji O, w taki sposób iż każdy ciąg jest O od wszystkich ciągów na prawo od niego: √ √ √ √ 1, log2 n, . . . , 4 n, 3 n, n, n, n · log2 n, n n, n2 , n3 , n4 , . . . , 2n , n!, nn .
(1) V1.0 – 9/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Złożoność
O(F4 )
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Kolejne górne ograniczenia
Algorytm o złożoności O(F4 )
Algorytm o złożoności O(F3 )
O(F3 )
Luka Algorytmiczna
Luka Algorytmiczna
Θ(F0 ) Złożoność naturalna Dowód, że złożonośc nie może być lepsza niż O(F2 )
Ω(F2 )
Ω(F1 )
Dowód, że złożoność nie może być lepsza niż O(F1 )
Czas poszukiwań optymalnego algorytmu
Kolejne dolne ograniczenia
V1.0 – 10/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Złożoność średnia algorytmu Niech cf (n, ~x ) będzie czasem pracy algorytmu dla problemu o rozmiarze n i konkretnych danych ~x . Niech P(~x ) oznacza prawdopodobieństwo wystąpienia danych ~x (przypadek R R dyskretny), lub niech P(~a < ~x < ~b) = ab11 . . . abmm µ(~x )dx1 . . . dxm będzie prawdopodobieństwem, że dane ~x znajdą się w zakresie (~a, ~b) (przypadek ciągły), funkcja µ(~x ) jest ~x . gęstością prawdopodobieństwa wektora losowego P Złożoność średnia jest O(Fs (n)), gdzie Fs (n) = ~x f (n, ~x )P(~x ) (przypadek dyskretny) R R Fs (n) = ab11 . . . abmm f (n, ~x )µ(~x )dx1 . . . dxm (przypadek ciągły).
N(n)
Możliwe histogramy czasu wykonań dwóch algorytmów rozwiązujących hipotetyczny problem algorytmiczny dla zbioru losowych zestawów danych. t
V1.0 – 11/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Problemy łatwo i trudno rozwiązywalne ... O(log(n)) problemy łatworozwiązywalne w praktyce
O(n) O(n log(n))
problemy łatworozwiązywalne
2
O(n ) O(n3 ) ... O(nk ) ... O(2n )
problemy trudnorozwiązywalne
O(n!) O(nn ) V1.0 – 12/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Funkcja złożności log(n) n n log(n) n2 2n n!
10 3.2 10 33.2 1000 1024 3.0 · 106
Notacja asymptotyczna
Z.O. L/H – przykłady
rozmiar problemu n 100 1000 6.6 10.0 100 1000 664.4 9.9 · 103 7746 60000 1.26 · 1030 1.07 · 10301 9.3 · 10157 4.0 · 102567
Już za tydzień na wykładzie
10000 13.3 10000 1.3 · 105 5.6 · 106 2.0 · 103010 > 105000
V1.0 – 13/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Funkcja złożoności czasowej f(n) log(n) n n log(n) n2 2n n!
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
maksymalny rozmiar problemu możliwy do rozwiązania w czasie (przy założeniu 106 operacji na sekundę) 1 sek 1 min 1 godz 1 rok 6
210 106 62746 1000 19 9
7
26·10 6 · 107 2.8 · 106 7746 25 11
9
23.6·10 3.6 · 109 1.3 · 108 60000 31 12
13
23·10 3 · 1013 8.0 · 1011 5.6 · 106 44 16
V1.0 – 14/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Przykłady problemów
V1.0 – 15/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Przykłady problemów
V1.0 – 16/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Przykłady problemów
V1.0 – 17/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Przykłady problemów
Nieroztrzygalność i nierozwiązywalność
Problemy nieroztrzygalne (nierozwiązywalne) — nie istnieje żaden algorytm poprawny, tzn. jakikolwiek algorytm nie zostanie opracowany, to zawsze będzie istniał taki zbiór poprawnych danych wejściowych, że 1
albo algorytm odda błędne wyniki,
2
albo zawiesi się,
3
albo będzie działał w nieskończoność.
Istnieje następujący podział algorytmów: 1
nieobliczalne/nierozstrzygalne – nie ma algorytmu,
2
trudno rozwiązywalne – nie ma algorytmu wielomianowego, łatwo rozwiązywalne – istnieją algorytmu wielomianowe.
3
V1.0 – 18/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Przykłady problemów
V1.0 – 19/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Przykłady problemów
Najprostsze podejście do rozwiązania problemu małpiej układanki, polega na sprawdzeniu wszystkich możliwych układów kart: 1
2
3
wybierana jest jedna z kart, i układana jest na wybranym miejscu (wszystkie możliwe miejsca zostały ponumerowane), na drugim miejscu można umieścić jedną z N − 1 kart, na kolejnym N − 2, etc., po ułożeniu należy sprawdzić czy warunki ułożenia kart zostały spełnione, liczba wszystkich możliwych ułożeń to: N · (N − 1) · (N − 2) · . . . · 3 · 2 · 1 = N!
(2)
Oznacza to iż podejście bezpośrednie wymaga O(N!) operacji .
V1.0 – 20/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Przykłady problemów
V1.0 – 21/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Przykłady problemów
Problem domina może być nierozstrzygalny. Jednak jeśli rozpatrzymy problem „węża domino” , to jest on rozstrzygalny, jeśli płaszczyzna, na której układamy węża jest skończona (ponieważ istnieje skończona liczba węży, która da się ulokować na skończonej płaszczyźnie). Jest on również rozstrzygalny na płaszczyźnie nie nieograniczonej. Jednakże, w przypadku dwóch połów nieograniczonej płaszczyzny, to na każdej takiej połowie problem jest nierozstrzygalny. Inny przykład problemu nierozstrzygalnego jest następujący: nie istnieje algorytm, który po wczytaniu jako danych dwóch zbiorów reguł składniowych R1 , R2 , może określić w skończonym czasie czy dwa zbiory reguł definiuje ten sam język L. Problem stopu algorytmów także jest nierozstrzygalny, gdyż nie istnieje automatyczny weryfikator poprawności programów/ algorytmów. Nie można także stwierdzić dla wszystkich algorytmów czy dany algorytm się zatrzyma dla wszystkich poprawnych danych wejściowych, lub też iż algorytm się zatrzyma dla pewnych wybranych danych. Co oznacza, że problem stopu jest nierozstrzygalny. Problemy nierozstrzygalne mają także (podobnie jak problemy rozwiązywalne) różne stopnie nierozstrzygalności. V1.0 – 22/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Przykłady problemów
Cztery typu problemów algorytmicznych: 1
wysoce nierozstrzygalne – okresowe domino,
2
nierozstrzygalne – nieograniczone domino,
3
trudno rozwiązywalne – ograniczone domino,
4
łatwo rozwiązywalne – ograniczone domino ze stałą szerokością,
Wyjaśnienia związane z problemem domina: 1
Domino ograniczone – problem pokrycia obszaru o wymiarach N × N za pomocą skończonego zbioru rodzajów kafelków T ,
2
Domino nieograniczone – problem pokrycia nieskończonego obszaru pomocą skończonego zbioru T ,
3
Domino okresowe – jak wyżej, ale pewien określony kafelek ma powtórzyć się w pokryciu nieskończenie wiele razy,
4
Domino o stałej szerokości albo wąż domino – czy dla danego T i liczby N można ze zbioru T ustawić prostokąt o wymiarach C × N (C — szerokość ustalona od górnie). V1.0 – 23/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Operacje na sumach
Sumy skończone Konwencja zapisu sum skończonych: n X
ai = a1 + a2 + a3 + . . . an−1 + an
(3)
i=1
Czasami stosowana jest ogólniejsza notacja (a) albo (b) X X (a) ai , (b) ai , i∈I
(4)
1≤i≤n i parzyste
gdzie I jest skończonym zbiorem indeksów. Jeśli zbiór I jest pusty to suma ma wartość zero. W przypadku (b) podaje się warunek definiujący zbiór indeksów. Informacje o sumach pochodzą z Ważniaka: http://wazniak.mimuw.edu.pl/index.php?title=Matematyka_dyskretna_1. V1.0 – 24/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Operacje na sumach
Elementarz na sumach Suma wyrażeń stałych, gdzie zmienna i jest zmienną wolną, nie związaną: n X
c = nc jeśli i w c jest zmienną wolną
(5)
i=1
Wzór na sumę kolejnych liczb naturalnych: n X
i = 1 + 2 + 3 + ... + N =
i=1
N(N + 1) 2
(6)
Suma stałej oraz iloczynu stałej i zmiennej zależnej: n X 1 (a + bi) = (a + bn)(n + 1) 2
(7)
i=0
V1.0 – 25/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Operacje na sumach
Elementarz na sumach Ciąg geometryczny: n X i=0
ax i =
a − ax n+1 1−x
dla x 6= 1
(8)
Trzy podstawowe prawa: n X
cai = c
i=1 n n X X (ai + bi ) = ai + i=1
i=1
X i∈I
ai =
n X
ai
(9)
bi
(10)
ap(i)
(11)
i=1 n X i=1
X p(i)∈I
gdzie p(i) to dowolna permutacja indeksów. V1.0 – 26/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Przykłady
Sumy skończone – przykład Obliczyć następującą sumę: n X
(a + kb) = a + (a + b) + (a + 2b) + (a + 3b) + . . . + (a + nb) =? (12)
k=0
Należy zauważyć: n X
(a + kb) =
k=0
n X k=0
(a + (n − k)b) =
n X k=0
(a + nb − kb)
(13)
Odpowiednio dodając sumy otrzymamy: 2
n X k=0
(a + kb) =
n X k=0
((a + kb) + (a + nb − kb)) = = (2a + nb)
n X
n X
(2a + nb)
k=0
1 = (2a + nb)(n + 1)
(14)
k=0 V1.0 – 27/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Przykłady
Sumy skończone – zaburzanie Metoda zaburzania polega na obliczeniu wartości Sn+1 za pomocą Sn np.: poprzez wydzielenie pierwszego i ostatniego elementu sumy: Sn + an+1 = a0 +
n X
ai+1
(15)
i=0
Obliczenie sumy ciągu geometrycznego n X
ax i + ax n+1 = ax 0 +
i=0
Wyznaczając
Pn
n X
i=0
ax i , a, x ∈ Z, x 6= 1:
ax i+1 = a + x
i=0
Pn
i=0
n X
ax i .
(16)
i=0
ax i otrzymamy: n X i=0
ax i =
a − ax n+1 , dlax 6= 1. 1−x
(17)
V1.0 – 28/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Przykłady
Sumy skończone – zaburzanie Inny przykład dla sumy n X i=0
Pn
i=0
i2i :
i2i + (n + 1)2n+1 = 0 · 20 + =2
n X i=0
n X
(i + 1)2i+1
i=0
i2i + 2
n X
2i = 2
i=0
n X i=0
i2i + 2 · (2n+1 − 1), (18)
Wartość
Pn
i=0
n X i=0
2i została określona „folię” wyżej:
i2i = (n + 1)2n+1 − 2(2n+1 − 1) = (n − 1)2n+1 + 2.
(19)
V1.0 – 29/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Przykłady
Sumy skończone – zaburzanie Technika zaburzania może zawieść np.: dla aby otrzymać wzór na sumę kwadratów: n X
i 3 + (n + 1)3 = 03 +
i=0
n X
Pn
i=0
i 2 , należy obliczyć
Pn
i=0
i3
(i + 1)3
i=0
= =
n X i=0 n X i=0
i3 + 3 i3 + 3
n X i=0 n X i=0
i2 + 3
n X i=0
i2 + 3
i+
n X
1
(20)
i=0
n(n + 1) + (n + 1). 2
Po eliminacji sześcianów otrzymujemy: 3
n X i=0 n X i=0
3 3 i 2 = (n + 1)3 − n(n + 1) − (n + 1) = (n + 1)((n + 1)2 − n − 1), 2 2 i2 =
(n + 1)(n2 + 2n + 1 − 32 n − 1) n(n + 12 )(n + 1) = . 3 3 (21)
V1.0 – 30/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Notacja asymptotyczna
Notacja asymptotyczna – za Ważniakiem Nie zawsze potrzebna jest dokładna informacja o oszacowaniu np.: łatwo oszacować wartość silni: n! = 1 · 2 · . . . · n ≤ nn posługując się trywialnym rozwinięciem: 1 · 2 · 3 · . . . · (n − 1) · n ≤ n · n · n ·{z. . . · n · n} | {z } | n elementów
n elementów
Nieco wysiłku i można także wskazać dolne oszacowanie, jeśli zauważy się że (n!)2 = (1 · . . . · n)(n · . . . · 1) =
n Y
i(n + 1 − i).
(22)
i =1
Potraktujmy i(n + 1 − i) = 41 (n + 1)2 − (i − 12 (n + 1))2 jako wielomian drugiego stopnia zmiennej i. Łatwo zauważyć, że dla i ∈ [1, . . . , n] przybiera on najmniejszą wartość w punkcie i = 1, a największą w punkcie i = 12 (n + 1). Zatem dla i ∈ {1, . . . , n} mamy n ≤ i(n + 1 − i) 6 41 (n + 1)2 i dalej n 1 nn 6 (n!)2 6 (n + 1)2 , (23) 4 czyli n
n 2 ≤ n! 6
n+1 2
n .
(24) V1.0 – 31/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Notacja asymptotyczna
Notacja asymptotyczna Funkcja asymptotycznie niewiększa od funkcji g (n) to taka funkcja f : N → R, dla której istnieją c > 0 i n0 ∈ N, że |f (n)| ≤ c · |g (n)| dla wszystkich n ≥ n0 . Dość często mówi się, że |f (n)| ≤ c · |g (n)| zachodzi dla prawie wszystkich liczb naturalnych n. Zbiór funkcji asymptotycznie niewiększych niż g (n) jest oznaczany przez O(g (n)).
c · |g(n)|
|f (n)|
n V1.0 – 32/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Notacja asymptotyczna
Funkcja asymptotycznie niewiększa – przykłady
Przykłady funkcji : 1 O(1), to zbiór funkcji ograniczonych przez stałą, 1
2 3 4 2
każda funkcja stała jest O(1) np. f (n) = 100 jest O(1), bo |f (n)| = 100 6 100 dla dowolnego n, (−1)n = O(1), bo |(−1)n | 6 1 dla dowolnego n, 1 = O(1), bo n1 ≤ 1 dla dowolnego n > 1, n fraclog nn = O(1), bo log n < n dla n > 1, zatem logn n 6 1 dla n > 1.
O(n) zbiór funkcji ograniczonych przez funkcję liniową: 1 2 3
wszystkie funkcje O(1) są też O(n), 10n + 25 = O(n), bo |10n + 25| ≤ 11n dla n ≥ 25, 2n + 3 log n − 100 = O(n), bo |2n + 3 log n − 100| 6 3n dla dowolnego n.
V1.0 – 33/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Notacja asymptotyczna
Funkcja asymptotycznie niewiększa – przykłady
Przykłady funkcji : 1 O(n2 ) zbiór funkcji ograniczonych przez funkcję kwadratową: 1 2 3 2
3n2 + 10n − 1 = O(n2 ), n(n+1) = O(n2 ), 2 3 log n + 2 = O(n2 ) (a także O(n) i O(log n)).
O(2n ) zbiór funkcji ograniczonych przez funkcję wykładniczą: 1
3 · 2n + n = O(2n ), bo n ≤ 2n , a zatem 3 · 2n + n ≤ 4 · 2n dla dowolnego n.
V1.0 – 34/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Notacja asymptotyczna
Funkcja asymptotycznie niemniejsza od funkcji g (n) to taka funkcja f : N −→ R, dla której istnieją c > 0 i n0 ∈ N, że c · |g (n)| ≤ |f (n)| dla wszystkich n ≥ n0 . Zbiór funkcji asymptotycznie niemniejszych niż g (n) oznaczamy przez Ω(g (n)).
|f (n)|
c · |g(n)|
n
V1.0 – 35/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Notacja asymptotyczna
Funkcja asymptotycznie podobna do funkcji g (n) to taka funkcja f : N −→ R, dla której istnieją c0 , c1 > 0 i n0 ∈ N, takie że c0 · |g (n)| 6 |f (n)| ≤ c1 · |g (n)| dla wszystkich n ≥ n0 . Zbiór funkcji asymptotycznie podobnych do g (n) oznaczamy przez Θ(g (n)), toteż Θ(g (n)) = O(g (n)) ∩ Ω(g (n)).
c1 · |g(n)|
|f (n)|
c2 · |g(n)|
n
V1.0 – 36/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Notacja asymptotyczna
Funkcja asymptotycznie mniejsza od funkcji g (n) to taka funkcja f : N −→ R, że dla każdego c > 0 istnieje n0 ∈ N, przy którym |f (n)| < c · |g (n)| dla wszystkich n ≥ n0 . Zbiór funkcji asymptotycznie mniejszych niż g (n) oznaczamy przez o(g (n)). f (n) A zatem f (n) = o(g (n)) wtedy i tylko wtedy, gdy lim = 0. n→∞ g (n) Funkcja asymptotycznie większa od funkcji g (n) to taka funkcja f : N −→ R, że dla każdego c > 0 istnieje n0 ∈ N, przy którym c · |g (n)| < |f (n)| dla wszystkich n ≥ n0 . Zbiór funkcji asymptotycznie większych niż g (n) oznaczamy przez ω(g (n)). g (n) A zatem f (n) = ω(g (n)) wtedy i tylko wtedy, gdy lim = 0. n→∞ f (n)
V1.0 – 37/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Notacja asymptotyczna
Dla funkcji f , g : N −→ R prawdziwe są następujące relacje:
jeśli f (n) = O(g (n)), g (n) = O(h(n)), to f (n) = O(h(n)), jeśli f (n) = Ω(g (n)), g (n) = Ω(h(n)), to f (n) = Ω(h(n)), jeśli f (n) = o(g (n)), g (n) = o(h(n)), to f (n) = o(h(n)), jeśli f (n) = ω(g (n)), g (n) = ω(h(n)), to f (n) = ω(h(n)), f (n) = Θ(g (n)) wtedy i tylko wtedy, gdy g (n) = Θ(f (n)), f (n) = O(g (n)) wtedy i tylko wtedy, gdy g (n) = Ω(f (n)), f (n) = o(g (n)) wtedy i tylko wtedy, gdy g (n) = ω(f (n)).
Dla funkcji f , g , f1 , f2 , g1 , g2 : N −→ R prawdziwe są następujące relacje: f (n) = O(f (n)),
f (n) = O(O(g (n))) wtedy i tylko wtedy, gdy f (n) = O(g (n)), f (n) = O |(g (n))| wtedy i tylko wtedy, gdy f (n) = O(g (n)),
f (n) = c · O(g (n)) wtedy i tylko wtedy, gdy f (n) = O(g (n)),
jeśli f1 (n) = O(g1 (n)) i f2 (n) = O(g2 (n)), to f1 (n) + f2 (n) = O(g1 (n)) + O(g2 (n)), jeśli f1 (n) = O(g1 (n)) i f2 (n) = O(g2 (n)), to f1 (n) · f2 (n) = O(g1 (n)g2 (n)). V1.0 – 38/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Notacja asymptotyczna
Twierdzenie o rekurencji uniwersalnej Dla funkcji T (n) zadanej przez Θ(1), dla n ∈ {0, 1} T (n) = a · T bn + f (n), dla n > 1
(25)
zachodzi: 1
jeśli f (n) = O(nlogb a− ) dla pewnego > 0, to T (n) = Θ(nlogb a ),
2
jeśli f (n) = Θ(nlogb a ), to T (n) = Θ(nlogb a lg n),
n jeśli f (n) = Ω(nlogb a+ ) dla pewnego > 0 oraz af ( ) ≤ cf (n) dla b pewnego c < 1 i prawie wszystkich n, to T (n) = Θ(f (n)). n Przykład dla przypadku pierwszego: T (n) = 16T + n lg n, dostajemy 4 kolejno: 3
1
a = 16, b = 4, f (n) = n lg n,
2
nlog4 16 = n2 , f (n) = O(n2− ), np. dla = 0.5,
3
zatem otrzymuje się T (n) = Θ(n2 ). V1.0 – 39/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Notacja asymptotyczna
Przykład dla drugiego przypadku: T (n) = 2T 1 2
n 2
+ 5n − 15, otrzymuje się
a = 2, b = 2, f (n) = 5n − 15, nlog2 2 = n, f (n) = Θ(n),
zatem z drugiego punktu Tw. wynika iż T (n) = Θ(n lg n). n Przykład dla trzeciego przypadku: T (n) = 2T + n lg n, wtedy 3 1 a = 2, b = 3, f (n) = n lg n, 3
nlog3 2 ≈ n0.6309 , f (n) ∈ Ω(nlog3 2− )dla = 0.1, n n n 2 2 3 af ( ) ≤ 2 · lg ≤ n lg n = f (n), b 3 3 3 3 4 zatem z trzeciego punktu Tw. wynika iż T (n) = Θ(n lg n). n Czasem „life is brutal”, i dla T (n) = 2T + n lg n, otrzymuje się 2 1 a = 2, b = 2, f (n) = n lg n, 2
2 3
nlog2 2 = n, n lg n ∈ Ω(n) ale dla dowolnego > 0, n lg n ∈ / Ω(n1+ ), co oznacza iż nie można zastosować Tw. o rekurencji uniwersalnej. V1.0 – 40/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Notacja asymptotyczna
Następne twierdzenie dotyczy równań o następującej postaci: s2n = 2sn + f (n)
(26)
Niech (sn ) będzie ciągiem rekurencyjnym o następującej postaci s2n = 2sn + f (n) dla n ∈ P Wtedy prawdziwe jest oszacowanie: " s2m = 2m s1 +
m−1 1 X f (2i ) 2 i =0 2i
# dla m ∈ N
(27)
B · 2m · m. 2
(28)
Jeśli, równanie rekurencyjne ma postać s2n = 2s1 + A + Bn dla stałych A i B, to oszacowanie jest następujące s2m = 2m · s1 + (2m − 1) · A + W szczególności gdy n = 2m , to otrzymujemy sn = ns1 + (n − 1)A +
B · n · log2 n 2
(29) V1.0 – 41/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Notacja asymptotyczna
Wyprowadzenie wzoru (28): s2n = 2sn + A + Bn, i f (n) = A + Bn,
(30)
więc S
2m
m
=2
m−1 1 X A + B · 2i s1 + 2 2i
! m
=2
i=0
m−1 1X A B · 2i s1 + + 2 2i 2i
! =
i=0
(31) 1 A 1 1 1 2m s1 + + B = 2m s1 + (2 − 21−m )A + B · m = i 2 2 2 2 2 i=0 i=0 1 B ·m B ·m m 1−m m −m A) + =2 s1 + A − A · 2 + = 2 s1 + (2A − 2 2 2 2 B ·m m B ·m m 2m · s1 + 2m · A − A · 2m · 2−m + 2 = 2m · s1 + (2m − 1)A + 2 2 2 m−1 X
m−1 X
!
V1.0 – 42/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Notacja asymptotyczna
Dwa przydatne wzory: m−1 X i=0
m
(1) − 1 1 1 1 1 1 = = 0 + 1 + 2 + . . . + m−1 = 1 · 21 i 2 2 2 2 2 2 −1
(32)
1 2m
−1 1 1 = ( m − 1) · −2 = 2(1 − m ) = 2 − 21−m 2 2 − 12
a także
m−1 X i=1
A = 21−m (2m − 1) A {z } | 2i
(33)
2−21−m
V1.0 – 43/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Przykłady złożoności obliczeniowej algorytmów oraz programów
V1.0 – 44/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Złożoność dla programu niskiego poziomu
Assembler Z80 – złożoność obliczeniowa Przykład znaleziony w Internecie, obliczana wartość pseudolosowa wg: R = (33 · R) mod 257: ld a, (seed) ; m 4 t 13(4,3,3,3) et 3.25 us ld b, a ; m 1 t 4 et 1.0 us rrca rrca rrca
; ; ; ;
mnożenie przez m 1 t 4 et 1.0 m 1 t 4 et 1.0 m 1 t 4 et 1.0
32 us us us
xor 0x1f
; m 2 t 7(4,3) et 1.75 us
add a, b sbc a, 255
; m 1 t 4 et 1.0 us ; przeniesienie ; m 2 t 7(4,3) et 1.75 us
ld (seed), a ; m 4 t 13(4,3,3,3) et 3.32 us ret ; m 3 t 10(4,3,3) et 2.50 us Oznaczenia m – ilość cykli maszynowych, t – cykle zegara, et – szacowany czas w µs dla zegara 4Mhz, razem ≈ 17.57µs.
V1.0 – 45/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Złożoność dla programów oraz algorytmów
Przywódca ciągu Przywódcą ciągu A[i], i = 1, . . . , n to taki element A[k], który występuje w ciągu więcej razy niż połowa długości tego ciągu. i l e := 0 ; f o r i := 1 if ( ile ile else if
t o n do = 0) then := i l e +1; j := i
(A [ i ]=A [ j ] ) t h e n i l e := i l e +1; else i l e := i l e −1; return A[ j ] ;
Złożoność obliczeniowa licząc operacje jednostkowe (bez względu na układ warunków) jest następująca: ! ! n n X X T (n) = 1 + 1 + 2 + 1 + 2 +1 = 2+ 6 = 2 + 6n = O(n) (34) i=1
i=1
V1.0 – 46/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Złożoność dla programów oraz algorytmów
Przywódca ciągu – wersja rekurencyjna Algorytm wyznaczający przywódcą ciągu A[i], i = 1, . . . , n w odmianie rekurencyjnej: i f n=1 t h e n przywódcą j e s t pojedynczy element t a b l i c y else ( 1 ) p o d z i e l i ć t a b l i c ę na d w i e połowy (2) r e k u r e n c y j n i e o b l i c z y ć przywódcę d l a l e w e j i p r a w e j połowy t a b l i c y ( 3 ) s p r a w d z i ć w c z a s i e O( n ) , k t ó r y z n i c h j e s t przywódcą c a ł o ś c i
Złożoność obliczeniowa licząc operacje jednostkowe (bez względu na układ warunków) jest następująca: n n T (n) = T (b c) + T (d e) + O(n), oraz T (1) = 1 2 2
(35)
A rozwiązanie można uzyskać korzystając z Tw. o rekurencji uniwersalnej: O(n log n). V1.0 – 47/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Złożoność dla programów oraz algorytmów
Złożoność algorytmu NWD
Jeden ze sposobów implementacji NWD to wykorzystanie faktu, że: NWD(m, n) = NWD(n, m mod n). { m, n ∈ N ∧ m 6= 0 ∧ n 6= 0} { r e z u l t a t : d = NWD(m, n ) } a :=m; b:=n ; w h i l e b 6= 0 do begin ( a , b ) = ( b , a mod b ) end d:= a
V1.0 – 48/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Złożoność dla programów oraz algorytmów
Złożoność algorytmu NWD
Dla danych liczb całkowitych, takich że m > n ≥ 0 algorytm NWD wykonuje co najwyżej 2 log2 (m + n) przebiegów pętli. Jeśli a ≥ b, to zachodzi następująca relacja (szczegóły w [Ross and Wright, 2000]): 2 (36) b + a mod b < · (a + b) 3 Inaczej mówiąc wartość a+b zmniejsza się co najwyżej 2/3 wartości w każdej iteracji pętli alg. NWD. Na początku alg. zachodzi równość a + b = m + n, k po k iteracjach otrzymuje się a + b ≤ ( 23 ) · (m + n). Ponieważ zawsze l
spełniona jest relacja a + b ≥ 1 + 0, toteż 1 ≤ ( 23 ) · (m + n) po ostatniej l
iteracji oznaczonej jako l . Zatem m + n ≥ ( 32 ) , logarytmując otrzymuje się log2 (m + n) ≥ log2 ( 32 ) > 12 l , i ostatecznie l < 2 · log2 (m + n).
V1.0 – 49/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Złożoność dla programów oraz algorytmów
Złożoność algorytmu sortowanie przez scalanie Wyznaczyć złożoność obliczeniową algorytmu sortowania przez scalanie (Merge scala dwa ciągi w czasie O(n): M e r g e S o r t (A , p , r ) i f p < r then q := p + r d i v 2 ; M e r g e S o r t (A , p , q ) M e r g e S o r t (A , q+1 , r ) Merge (A , p , q , r )
Złożoność obliczeniowa jest opisana przez następującą rekurencję: 1, gdy n = 1 T (n) = 2T ( n2 ) + n, gdy n > 1
(37)
V1.0 – 50/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Złożoność dla programów oraz algorytmów
Wyznaczyć złożoność poniższej funkcji wybierającej k-ty element najmniejszy: function select_k ( var A : v e c t o r ; n , k : index ) ; var i , j , mini : index ; tmp : i n t e g e r ; begin f o r i :=1 to k do begin m i n i := i ; f o r j := i +1 to n do i f A [ j ] < A [ m i n i ] then m i n i := j ; tmp:=A [ i ] ; A [ i ] : =A [ m i n i ] ; A [ m i n i ] : = tmp ; end ; s e l e c t _ k :=A [ k ] ; end ;
V1.0 – 51/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
Złożoność dla programów oraz algorytmów
Złożoność obliczeniowa dla select_k: k n X X tc + T (n) = 2tc + 3t3 + tc i=1
(38)
j=i+1
Pętla zewnętrzna wykona się k razy i wpływa na ilość wykonań w pętli wewnętrznej, której ilość wykonań można zapisać jako: (n − 1) + (n − 2) + (n − 3) + . . . + (n − k) =
(2n − k − 1)k 2
(39)
Po eliminacji pętli wewnętrznej i zewnętrznej mamy T (n) = ktc + ((2n − k − 1)ktc ) + 3kt3 + tc =
(40)
2
ktc + (2nk − k − k)tc + 3kt3 + tc
Dla k = n mamy przypadek najgorszy i O(n2 ), dla k = 1 złożoność to O(n), ogólnie O(n · k). V1.0 – 52/ 53
Wprowadzenie
Algorytmy
Operacje na sumach
Notacja asymptotyczna
Z.O. L/H – przykłady
Już za tydzień na wykładzie
W następnym tygodniu między innymi
Tematyka jaka będzie poruszana w następnym tygodniu: 1
Model algorytmiczny
2
Model obwodowy
3
Maszyna licznikowa
4
Maszyna RAM
Dziękuje za uwagę!!!
V1.0 – 53/ 53
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Modele algorytmiczne Maszyny proste, obwody logiczne Osoba prowadząca wykład i ćwiczenia: dr inż. Marek Sawerwain Instytut Sterowania i Systemów Informatycznych Uniwersytet Zielonogórski e-mail :
[email protected] tel. (praca) : 68 328 2321, pok. 328a A-2, ul. prof. Z.Szafrana 2, 65-246 Zielona Góra
Ostatnia zmiana: 8 listopada 2012
V1.1 – 1/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Spis treści 1
Wprowadzenie Plan wykładu
2
Modele obliczeń Biologiczny model obliczeniowy Model obliczeń biologicznych/molekularnych Najważniejsze rezultaty Filtrujący model równoległy Obwody logiczne
3
Maszyny proste Maszyna licznikowa Maszyna RAM A gdy trzeba coś policzyć co ma przecinek Złożoność obliczeniowa RAM
4
Już za tydzień na wykładzie
V1.1 – 2/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Plan wykładu
Plan wykładu – spotkania tydzień po tygodniu
(1) Informacje o wykładzie, poprawność algorytmów (2) Poprawność algorytmów – logika Hoarego (3) Analiza złożoności kodu wysokiego i niskiego poziomu (4) ⇒ Modele algorytmiczne – maszyny proste, obwody logiczne ⇐ (5) Modele algorytmiczne – maszyna Turinga oraz rachunek lambda (6) Automaty deterministyczne (7) Automaty niedeterministyczne (8) Gramatyki regularne i bezkontekstowe
V1.1 – 3/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Plan wykładu
Plan wykładu – spotkania tydzień po tygodniu
(9) Gramatyki i automaty ze stosem (10) Algorytmy równoległe (11) Klasy złożoności obliczeniowej (12) Pamięć logarytmiczna i wielomianowa (13) Problemy NP-zupełne (14) Wstęp do obliczeń kwantowych (15) Wybrane algorytmy kwantowe
V1.1 – 4/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Plan wykładu
Plan wykładu 1
Model obliczeniowy 1 2
2
Biologiczny model obliczeń 1 2 3
3
na czym bazuje model biologiczny, przykładowe modele, permutacje i ścieżka Hamiltona.
Obwody obliczeniowe: 1 2 3 4
4
Przykłady modeli obliczeniowych Hipoteza Churcha-Turinga
bramki logiczne, obwody logiczne, uniwersalny zestaw bramek, odwracalne obwody logiczne.
Maszyny proste: 1 2 3
Maszyna licznikowa, Maszyna RAM, Złożoność obliczeniowa. V1.1 – 5/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Plan wykładu
Przydatne materiały
Materiały wykorzystane podczas tworzenia tego wykładu, a także przydatne do dalszych studiów: 1
jak zwykle smerf Ważniak, służy pomocą: http://wazniak.mimuw.edu.pl/,
2
Harel D., Rzecz o istocie informatyki, WNT, 2000,
3
symulator maszyny RAM: http://mmsyslo.pl/ram/maszyna.html,
4
książka obejmująca zagadnienia biologicznego modelu obliczeniowego: Martyn Amos, Theoretical and Experimental DNA Computation, Springer-Verlag Berlin Heidelberg, 2005, http://www.dcs.ex.ac.uk/~mramos,
5
a model kwantowy będzie omawiany na ostatnich wykładach.
V1.1 – 6/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Modele obliczeń Przykładowe modele obliczeniowe: 1
maszyna Turinga (A.Turing),
2
rachunek lambda (A.Church),
3
funkcje rekurencyjne (S.Kleene)
4
automaty,
5
obwody logiczne,
6
model biologiczny,
7
model kwantowy.
Aktualnie uważa się iż wszystkie modele są tak samo silne, w sensie rozwiązywania problemów, tzn. nie istnieje problem, który można rozwiązać w modelu A ale nie można w pozostałych modelach. W przypadku modeli kwantowego i biologicznego, istnieją przykłady problemów, które można rozwiązać szybciej niż w pozostałych modelach. V1.1 – 7/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Modele obliczeń – przykłady
Trzy ważne modele obliczeń:
(I)
(II)
(III)
Deterministyczny automat skończony jest opisany przez skończoną liczbę stanów i skończoną liczbę dopuszczalnych przejść pomiędzy podanymi stanami. Niektóre ze stanów oznacza się jako tzw. stany akceptujące. Wejściowy ciąg symboli jest odczytywany kolejno symbol po symbolu, oraz po odczytaniu każdego symbolu wykonywane jest przejście do innego stanu. Po odczytaniu ostatniego symbolu, jeśli maszyna przejdzie do stanu akceptującego, to uważa się iż ciąg symboli został poprawnie rozpoznany. Automat ze stosem analogiczny jak poprzednio, jednakże nowym elementem jest dodanym stos, na którym można zapisać dowolną ilość symboli. W każdym przejściu dodatkowo należy określić, czy nowy symbol powinien zostać zapisany na stosie bądź też odczytany z wierzchołka stosu. Maszyna Turinga idea podobna do automatu skończonego, jednakże dodano nieskończoną taśmę, na której maszyna może zapisywać i odczytywać symbole, przemieszczając się po niej w lewą bądź w prawą stronę.
V1.1 – 8/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Hipoteza Churcha-Turinga – nim przejdziemy do przykładów modeli Choć istnieje wiele modeli obliczeniowych, to wszystkie mają pewną wspólną cechę: Hipoteza Churcha-Turinga Każdy problem algorytmiczny, dla którego można znaleźć algorytm, i podać implementację tego algorytmu w dowolnym języku (modelu obliczeniowym), i realizować jego wykonanie na dowolnym komputerze przy nieograniczonych zasobach czasu oraz pamięci jest także rozwiązywalny przez maszynę Turinga. Powyższą hipotezę, można też podać w krótszej wersji: Hipoteza Churcha-Turinga Każdy problem, który może być intuicyjnie uznany za obliczalny, jest rozwiązywalny przez maszynę Turinga. V1.1 – 9/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Biologiczny model obliczeniowy
Biologiczny model obliczeniowy materiał dodatkowy
V1.1 – 10/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Biologiczny model obliczeniowy
Łańcuch DNA
Łańcuch DNA jest zbudowany z czterech zasad azotowych, adeniny A i guaniny G (zasady purynowe) oraz cytozyny C i tyminy T (zasady pirymidynowe), w przypadku niektórych wirusów zamiast tyminy występuje uracyl U. Zasady tworzą następujące pary:
Struktura chemiczna DNA:
A-T (A-U) G-C T-A (U-A) C-G
Operacje wykonywane na łańcuchach DNA to: synteza, rozplatanie, splatanie, łączenie łańcuchów. V1.1 – 11/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Model obliczeń biologicznych/molekularnych
Przykłady modeli obliczeń molekularnych
Cztery podstawowe (naturalne) modele obliczeń molekularnych: model filtrujący (filtering model), model łączący (splicing model), model konstruktywny (constructive model), model membranowy (membrane model), model p-systemów (odmiana modelu membranowego).
V1.1 – 12/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Najważniejsze rezultaty
Najważniejsze rezultaty
Problem Directed Hamiltonian path Contact network satisfiability Circuit satisfiability MAX-Circuit-Satisfiability Regular-Circuit-Satisfiability 1-tape NTM Circuit satisfiability via 1-NTM Cellular Automata PSPACE Polynomial Hierarchy
Bio kroki O(n) O(s) O(s) O(s) O(s) O(t) Θ(s 2 ) 1 O(S) O(s)
Nitki DNA n! 2n 2n 2n 2n 2N 2n t ·S 22S 2n
Oznaczenia: n – liczba wierzchołków, zmiennych, s – liczba bramek, t – czas, N – liczba bitów niedeterministycznych, S – wielkość przestrzeni, V1.1 – 13/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Filtrujący model równoległy
Filtrujący model równoległy
Podstawowe równoległe operacje w modelu filtrującym: remove(U, {Si }) – operacja usuwa ze zbioru U dowolny łańcuch znaków zawierający co najmniej jedno wystąpienie podciągu Si , union({Ui }, U) – operacja tworzy zbiór U będący sumą wszystkich zbiorów Ui , copy (U, {Ui }) – operacja powiela zbiór U na Ui kopii, select(U) – operacja losowo wybiera element ze zbioru U, jeśli zbiór U jest pusty, to zwrócony zostanie pusty element.
V1.1 – 14/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Filtrujący model równoległy
Generowanie permutacji Utworzenie zbioru Pn zawierającego wszystkie permutacje liczb całkowitych {1, 2, . . . , n}. Wejście: Zbiór U zawierający wszystkie łańcuchy o postaci p1 i1 p2 i2 . . . pn in , gdzie j, pj jednoznacznie określa pozycję j dla każdego ij w 1, 2, . . . , n. Oznacza to że każdy ciąg znaków składa się z n liczb całkowitych z wieloma wystąpieniami tej samej liczby całkowitej. 1: 2: 3: 4: 5: 6: 7: 8:
for j = 1 to n - 1 do do copy(U, {U1 , U2 , ..., Un }) for i = 1, 2, . . . , n and all k > j do in parallel remove(Ui , {pj 6= i, pk i}) end for union({U1 , U2 , . . . , Un }, U) end for Pn := U
Złożoność: O(n) dla czasu równoległego. V1.1 – 15/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Filtrujący model równoległy
Ścieżka Hamiltona
Wejście: Zbiór wejściowy U oraz zbiór Pn wszystkich permutacji liczb całkowitych od 1 do n podobnie jak w przypadku permutacji. Liczba i na pozycji pk w jednej z otrzymanych permutacji posiada następującą interpretację: łańcuch znaków reprezentuje jedno z rozwiązań, gdzie wierzchołek i jest odwiedzany w kroku k. 1: 2: 3: 4:
for 2 ¬ i ¬ n − 1 and j, k such that (j, k) ∈ / E do in parallel remove(U, {jpi k}) end for select(U)
Złożoność: Stały czas równoległy w zależności od Pn .
V1.1 – 16/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Obwody logiczne
Modele algorytmiczne Obwody obliczeniowe albo obwody logiczne
V1.1 – 17/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Obwody logiczne
Obwody logiczne
Istnieje alfabet A = {0, 1}, dla którego obwody logiczne obliczają funkcje n m {0, 1} → {0, 1} . Podstawowe elementy, czyli bramki logiczne jakie są używane w obwodach są reprezentowane przez następujące funkcje: 1 ∧ : A2 → A, (bramka koniunkcji) zdefiniowana przez warunek ∧(x1 , x2 ) = 1 ⇔ x1 = x2 = 1, 2
∨ : A2 → A, (bramka alternatywy) określona przez warunek ∨(x1 , x2 ) = 0 ⇔ x1 = x2 = 0,
3
¬ : A → A, (bramka negacji) zdefiniowana przez relację ¬x = 1 − x.
Uzupełnieniem może być bramka alternatywy wykluczającej (XOR): 1
⊕ : A2 → A, (bramka XOR) zdefiniowana przez warunek ∧(x1 , x2 ) = 1 ⇔ x1 = 0, x2 = 1 ∨ x1 = 1, x2 = 0.
V1.1 – 18/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Obwody logiczne
Bramki logiczne
Przykłady symboli dla kilku bramek logicznych: OR2
AND2
NOR2
NOT
NAND2
XOR2
A1 A
FANOUT A2
V1.1 – 19/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Obwody logiczne
Podstawowe bramki logiczne
Trzy podstawowe bramki logiczne do budowy obwodów logicznych: OR2
AND2
A 0 0 1 1
OR2 B 0 1 0 1
O 0 1 1 1
A 0 0 1 1
AND2 B O 0 0 1 0 0 0 1 1
NOT
NOT A O 0 1 1 0
V1.1 – 20/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Obwody logiczne
Obwód logiczny Obwód logiczny jest reprezentowany przez skierowany graf acykliczny, gdzie węzły zawierają zmiennej wejściowe, zmienne wyjściowe oraz bramki logiczne. W dowolnym węźle wejściowym nie krawędzi przychodzących, i podobnie w dowolnym węźle wyjściowym nie ma krawędzi wychodzących. W przypadku obwodów logicznych krawędzie grafu są nazywane także połączeniami. Liczba węzłów w danym obwodzie determinuje także złożoność obwodu logicznego. Obwód logiczny o n zmiennych wejściowych oznaczonych x1 , x2 , . . . , xn i m wyjściowych y1 , y2 , . . . , yn w określa funkcję An → Am , gdzie zarówno dane wejściowe oraz wyjściowe są kodowane za pomocą wartości zero oraz jedność, a każda funkcja podstawowa, jak funkcja koniunkcji, alternatywy oraz negacji jest obliczana przez odpowiednie bramki.
V1.1 – 21/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Obwody logiczne
Półsumator jako funkcja A2 → A2
Półsumator można potraktować jako funkcję f : A2 → A2 , określoną w następujący sposób: 1
f (0, 0) = (0, 0),
2
f (0, 1) = (0, 1),
3
f (1, 0) = (0, 1),
4
f (1, 1) = (1, 0).
Ogólnie f (x1 , x2 ) = (y1 , y2 ) oraz y1 = (x1 + x2 ) mod 2, a wartość y2 reprezentuje bit przeniesienia, y2 = (x1 · x2 ).
V1.1 – 22/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Obwody logiczne
Półsumator
A XOR2
O
B O – output C – carry AND2
C
Tabela prawdy dla półsumatora, A oraz B bity wejściowe, natomiast O to wartość sumy natomiast C oznacza bit przeniesienia.
A 0 0 1 1
B 0 1 0 1
O 0 1 1 0
C 0 0 0 1
V1.1 – 23/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Obwody logiczne
Jednobitowy pełny sumator O – output C – carry
A
C1
O
O
ADDR B
A
A
O ADDR
B
B
OR2
C
C
Opis działania sumatora jednobitowego: O = A ⊕ B ⊕ C1 , C = A · B + (A ⊕ B) · C1 A także tabela prawdy:
C
A B 0 0 0 0 0 1 0 1 1 0 1 0 1 1 1 1
C1 0 1 0 1 0 1 0 1
O 0 0 0 1 0 1 1 1
C 0 1 1 0 1 0 0 1V1.1 – 24/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Obwody logiczne
1/2 + 1 = "4 bits full adder"
C A(3:0) B(3:0)
Pełny czterobitowy układ sumujący, zbudowanych pełnych sumatorów jednobitowych, C oznacza przeniesienie, A oraz B to wartości bitowe, które są dodawane.
C A(0) B(0)
A
O
B(1)
A
CO
O
B
B(2)
A
CO
O
B
B(3)
A B
O(2)
Full Adder CO
C A(3)
O(1)
Full Adder
C A(2)
O(3:0)
Full Adder
B
C A(1)
O(0)
O
O(3)
Full Adder CO
CO
V1.1 – 25/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Obwody logiczne
Zestawy bramek uniwersalnych
Tw. E.Posta o zupełnym zbiorze funkcji logicznych Dowolna funkcja An → Am może zostać obliczona za pomocą obwodu logicznego zbudowanego z bramek koniunkcji, alternatywy oraz negacji. Szkic dowodu: Zbiór bramek S nazywamy uniwersalnym, jeżeli wszystkie funkcje An → Am mogą być zrealizowane za pomocą bramek ze zbioru S. Należy pokazać że and, or, not jest uniwersalnym zestawem bramek. Po pierwsze wszystkie funkcje An → Am są obliczalne ponieważ można utworzyć m pomocniczych funkcji obliczających wartość pojedynczego bitu. Łatwo wykazać iż wartość funkcji a : x1 ∨ x2 ∨ x3 wynosi 0 jeśli x1 = x2 = x3 = 0, co można rozszerzyć na dowolną ilość zmiennych. Analogicznie funkcja b : x1 ∧ x2 ∧ x3 przyjmuje 1, jeśli x1 = x2 = x3 = 1.
V1.1 – 26/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Obwody logiczne
Zestawy bramek uniwersalnych Szkic dowodu cd: Dla każdego a = (a1 , a2 , . . . , an ) ∈ An można określić funkcję Ma taką, że Ma (x1 , x2 , . . . , xn ) = φ1 (x1 ) ∧ φ2 (x2 ) ∧ . . . ∧ φn (xn ), gdzie φi (xi ) = 1, jeśli ai = 0 oraz φi (xi ) = xi , jeśli ai = 1. Co oznacza iż funkcja Ma może zostać skonstruowana za pomocą bramek and oraz not. Wiadomo też z poprzedniego przykładu Ma (x1 , x2 , . . . , xn ) = 1 ⇔ ∀i ψi (xi ) = 1. Ponieważ, xi , jeśli ai = 1, φi (xi ) = ¬xi , jeśli ai = 0, a więc φi (xi ) = 1 ⇔ xi = ai . Pozwala to stwierdzić, że Ma jest funkcją charakterystyczną zbioru {a} : Ma (x) = 1 ⇔ x = a. Stosując funkcje charakterystyczne Ma łatwo skonstruować dowolną funkcję f : f = Ma1 ∨ Ma2 ∨. . .∨Mak , gdzie elementy a1 , a2 , . . . , ak ze zbioru An przyjmują wartość 1 dla danej f . V1.1 – 27/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Obwody logiczne
Bramki odwracalne Bramki odwracalne realizują funkcje An → An , liczba bitów wejściowych i wyjściowych jest taka sama. Istnieje (2n )! bramek odwracalnych. Przykład bramki odwracalnej tzw. bramki Toffoliego T : A3 → A3 , gdzie T (x1 , x2 , x3 ) = (x1 , x2 , x3 ⊕ x1 · x2 ). dwa pierwsze bity pozostawiane są bez mian, natomiast bit trzeci jest negowany, jeśli dwa pierwsze przyjmują wartość 1. X
X
X
X
Y
Y
Y
Y
XY ⊕ Z
Z
XY ⊕ Z
Z
X
(a)
(b) V1.1 – 28/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Obwody logiczne
Obwody odwracalne Obwód odwracalny, to obwód logiczny złożony z bramek odwracalnych, taki obwód także jest zdolny do realizacji funkcji logicznych, co więcej, także istnieją uniwersalne zbiory bramek, wiadomo także iż: 1
bramki negacji są odwracalne,
2
choć bramki koniunkcji nie są odwracalne, to można je za symulować za pomocą bramki T , w następujący sposób: T (x1 , x2 , 0) = (x1 , x2 , x1 · x2 )
3
korzystając z prawa x1 ∨ x2 = ¬(¬x1 ∧ ¬x2 ), to bramkę alternatywy można zastąpić koniunkcją oraz negacją,
4
wyjście zwielokrotnione może być symulowane za pomocą CNOT : (x1 , x2 ) = (x1 , x1 · x2 ⊕ 2) w następujący sposób CNOT (x1 , 0) = (x1 , x1 ).
Bramka Toffoliego jest uniwersalną bramką odwracalną.
V1.1 – 29/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Obwody logiczne
Obwody odwracalne – przykłady Półsumator jako obwód odwracalny (zastosowano bramkę CNOT oraz X (bramka negacji)): • |ai |ai x |bi NOT(a ⊕ b) Schemat obwodu, dla pełnego sumatora, gdzie nie następuje modyfikacja badanych stanów a i b: a b 0 0
•
• •
• X
•
a
X
b •
c •
d
Wadą jest konieczność stosowania dodatkowego bitu który decyduje o przywróceniu poprawnej wartości dla bitu b.
V1.1 – 30/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Modele algorytmiczne Maszyny proste
V1.1 – 31/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Maszyna licznikowa
Definicja maszyny licznikowej Maszyna licznikowa jest oparta o cztery typy instrukcji. Pierwsza to przypisanie zera do zmiennej: X ← 0 albo x:=0. Drugi typ instrukcji to zwiększenie wartości zmiennej o jedność i przypisanie wyniku do tej samej bądź innej zmiennej: X←Y+1 Dopełnieniem tego typu instrukcji jest zmniejszenie wartości o jedność: X←Y−1 Ostatnim typem instrukcji jest instrukcja skoku, jeśli zmienna jest równa zeru: jeśli X = 0 skocz-do ETY. Jeśli w programie nie ma etykiety o podanej nazwie, to program przerwie działanie. Koniec nastąpi również, gdy zostanie wykonana ostatnia instrukcja w programie.
V1.1 – 32/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Maszyna licznikowa
Dodawanie liczb
Z := 0; _liczymy_dalej: if Y = 0 then goto _prawie_koniec; X := X + 1; Y := Y - 1; if Z = 0 then goto _liczymy_dalej; _prawie_koniec: 8: Z := X + 1; 9: Z := Z - 1; 1:
2: 3: 4: 5: 6: 7:
V1.1 – 33/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Maszyna licznikowa
Odejmowanie liczb
Z := 0; _liczymy_dalej: if Y = 0 then goto _prawie_koniec; X := X - 1; Y := Y - 1; if Z = 0 then goto _liczymy_dalej; _prawie_koniec 8: Z := X + 1; 9: Z := Z - 1; 1:
2: 3: 4: 5: 6: 7:
V1.1 – 34/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Maszyna licznikowa
Mnożenie dwóch liczb
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12:
U := 0; Z := 0; _A: if X = 0 then goto _L; X := X - 1; V := Y + 1; V := V - 1; _B: if V = 0 then goto _A; V := V - 1; Z := Z + 1; if U = 0 then goto _B;
V1.1 – 35/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Maszyna RAM
Maszyna RAM Maszynę o dostępie swobodnym (Random Access Machine — RAM) została zaproponowana w połowie lat czterdziestych XX wieku przez Johna von Neumanna we współpracy z Johnem Williamem Mauchly i J. Presper Eckertem. Maszyna RAM powstała jako narzędzie edukacje a celem było zrozumieniu zasad działania pierwszych maszyn elektronowych tj. maszyn EDVAC oraz ENIAC. Główne elementy maszyny RAM 1
taśma wejściowa (LI ), z której odczytywane są dane wejściowe,
2
taśma wyjściowej (LO), gdzie umieszczane są wyniki,
3
pamięć o dostępie swobodnym, poszczególne komórki są adresowane przez Ci , i = 0, 1, 2, . . ., wartość z i-tej komórki to ci albo c(i).
4
lista n instrukcji stanowiąca program, umieszczone w odrębnej przestrzeni niż RAM, Π = (π1 , π2 , . . . , πn . )
Istniej też licznik rozkazów, wskazujący aktualnie wykonywaną instrukcję. V1.1 – 36/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Maszyna RAM
Schemat maszyny RAM Lista wejściowa ... Akumulator
Program
Pamięć operacyjna
Licznik rozkazów
Lista wyjściowa ... ... V1.1 – 37/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Maszyna RAM
Instrukcje maszyny RAM
W skład ciągu instrukcji programu Π wchodzą min. następujące operacje: LOAD op ADD op JUMP ety
READ op SUB op JFTZ ety
STORE op MULT op JZERO ety
WRITE op DIV op HALT
gdzie op może przyjmować postać: 1
liczby całkowitej – ADD =3 ,
2
wartości adresującej pamięć RAM – MULT 3,
3
wartości adresującej pamięć RAM pośrednio – DIV *5.
Natomiast instrukcja JUMP ety, oznacza przesunięcie licznika instrukcji do wskazanej etykiety.
V1.1 – 38/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Maszyna RAM
Techniki adresowania Adresowanie natychmiastowe load =10
10 c0
c1
c2
c3
c4
c5
c6
...
Adresowanie bezpośrednie load 6
12 c0
12 c1
c2
c3
c4
c5
c6
...
Adresowanie pośrednie load 6
17 c0
4
17 c1
c2
c3
c4
c5
c6
... V1.1 – 39/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Maszyna RAM
Spis instrukcji maszyny RAM LP. 1
2 3
4 5 6 7 8
9 10 11 12
Instrukcja LOAD =a LOAD n LOAD *n STORE n STORE *n ADD =a ADD n ADD *n SUB =a MULT =a DIV =a READ n READ *n WRITE =a WRITE n WRITE *n JUMP ety JFTZ ety JMPZ ety HALT
Znacznie c(0) ← a c(0) ← c(n) c(0) ← c(c(n)) c(n) ← c(0) c(c(n)) ← c(0) c(0) ← c(0) + a c(0) ← c(0) + c(n) c(0) ← c(0) + c(c(n)) c(0) ← c(0) − a c(0) ← c(0) ∗ a c(0) ← c(0) div a c(0) ← LI i c(c(n)) ← LI i LO i ← a LO i ← c(n) LO i ← c(c(n)) II ← ety if c(0) > 0 then II ← ety if c(0) = 0 then II ← ety zatrzymanie pracy maszyny V1.1 – 40/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Maszyna RAM
Największy wspólny dzielnik f u n c t i o n gcd ( a : i n t e g e r ; b : i n t e g e r ) : i n t e g e r ; var c : integer ; begin w h i l e b <> 0 do begin i f a >= b t h e n a := a − b else begin c := b ; b := a ; a := c ; end ; end ; gcd := a ; end ; V1.1 – 41/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Maszyna RAM
Największy wspólny dzielnik – początek . i n s i z e 20 . o u t s i z e 20 . r a m s i z e 20 . i n l i s t 8 ,6 ,0 ,0 . start read 1 read 2 4: load 2 jmpz 19 sub 1 j o t z 12 load 1 sub 2 store 1 jump 4 12: load 2 V1.1 – 42/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Maszyna RAM
Największy wspólny dzielnik – koniec
store 3 load 1 store 2 load 3 store 1 jump 4 19: write 1 halt . end
V1.1 – 43/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Maszyna RAM
Wartość 5n read 1 load 1 jmpz L2 l o a d =5 L1 : s t o r e 2 load 1 sub =1 store 1 jmpz L3 load 2 mult =5 jump L1 L2 : w r i t e =1 halt L3 : w r i t e 2 halt
; ; ; ; ; ; ; ;
odczytanie n i z a p i s do a k u m u l a t o r a j e ś l i n=0 i d z i e m y do L2 podstawa wynik c z ę ś c i o w y licznik pętli zmniejszenie licznika pętli
; ; ; ;
wynik c z ę ś c i o w y j e s t mnożony p r z e z p i ę ć s k o k na p o c z ą t e k p ę t l i m n o ż ą c e j w y n i k gdy w y k ł a d n i k równy z e r o
; w y n i k gdy w y k ł a d n i k w i ę k s z y od z e r a V1.1 – 44/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Maszyna RAM
Wartość nn – z wykładu M.Szczuka/MIMUW/Model Obliczeń Zadanie to obliczenie wartości funkcji (n) = nn , i jeśli n = 0 to f (0) = n. Program napisany w języku wysokiego poziomu przedstawia się następująco: c (1):= n ; i f ( n = 0) return 0; else begin c (2):= c ( 1 ) ; c (3):= c (1) − while c (3) > begin c (2) c (3) end ; return c (2); end ;
1; 0 do = c (2) ∗ c (1); = c (3) − 1;
V1.1 – 45/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Maszyna RAM
Wartość nn Za wykładem M.Szczuka/MIMUW/Model Obliczeń. . s i z e 20 ,20 ,20 . i n l i s t 4 ,0 ,0 ,0 . start read 1 load 1 j o t z p os w r i t e =0 jump e n d i f
; ; ; ; ; ;
w c z y t a n i e n do c ( 1 ) w c z y t a n i e n do akumulatora i f ( c (1) = 0 ) then r e t u r n (0) s k o k na k o n i e c programu
pos : load 1 store 2 sub =1 store 3
; e l s e – c ( 1 ) = n do ; akumulatora ; c ( 2 ) := c ( 1 ) ; c ( 0 ) := c ( 0 ) − 1 ; c ( 3 ) := c ( 1 ) − 1 V1.1 – 46/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Maszyna RAM
Wartość nn while : load 3 jotz continue jump e n d w h i l e continue : load 2 mult 1 store 2 load 3 sub =1 store 3 endwhile : write 2 endif : halt . end
; c ( 3 ) do a k u m u l a t o r a ; while c (3) > 0 ; gdy c ( 3 ) = 0 − z a k o n c z ; ; ; ; ; ;
c (2) c (0) c (2) c (0) c (0) c (3)
do := := := := :=
akumulatora c (2) ∗ c (1) c (2) ∗ c (1) c (2) c (0) − 1 c (3) − 1
; return ( r2 ) ; k o n i e c programu
V1.1 – 47/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Maszyna RAM
Suma elementów na liście wejściowej – początek
. i n s i z e 20 . o u t s i z e 20 . r a m s i z e 20 . i n l i s t 10 ,1 ,0 ,0 ,1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,10 . start read read read read load
1 2 3 4 1
add 2
V1.1 – 48/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Maszyna RAM
Suma elementów na liście wejściowej – i koniec
petla1 : sub 2 store 1 jmpz k o n i e c read 3 load 3 add 4 store 4 load 1 jump p e t l a 1 koniec : write 4 halt . end
V1.1 – 49/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Maszyna RAM
Silnia wg. maszyny RAM – Początek,
. i n s i z e 20 . o u t s i z e 20 . r a m s i z e 20 . i n l i s t 10 ,1 ,1 ,1 . start read read read read
1 2 3 4
load 1
V1.1 – 50/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Maszyna RAM
Silnia wg. maszyny RAM – oraz główna część petla1 : store 1 jmpz k o n i e c load 3 mult 4 store 4 load 3 add 2 store 3 load 1 sub 2 jump p e t l a 1 koniec : write 4 halt . end V1.1 – 51/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
A gdy trzeba coś policzyć co ma przecinek
P = πr 2 Program do obliczania wartości pola koła dla maszyny RAM: . i n s i z e 20 . o u t s i z e 20 . r a m s i z e 20 . i n l i s t 5 ,314 ,100 ,0 . start read 0 read 1 read 2 mult 0 mult 1 write 0 div 2 write 0 halt . end V1.1 – 52/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Złożoność obliczeniowa RAM
Złożoność obliczeniowa RAM Model maszyny RAM jest dość nierealistyczny, gdyż należy podkreślić że posiadamy nieskończenie (ale przeliczalnie) wiele rejestrów, które są w stanie przechowywać dowolnie duże liczby całkowite, bez wskazywania dodatkowych kosztów dotyczących: odczytu, zapisu oraz realizacji przetwarzania. Dlatego bardziej realne oszacowanie złożoności obliczeniowej wymaga określenia kosztu wykonywania poszczególnych operacji. Koszty te są uzależnione od rozmiaru argumentu. Przyjmuje się, że koszt przetworzenia liczby całkowitej n jest równy jej długości w zapisie pozycyjnym i wynosi log n. Przykłady dla wybranych instrukcji RAM: 1
add 2 – 2 log(c(0)) + log(c(1))
2
mult =4 – 2 log(c(0)) + 2bin=11
3
load *5 – log(c(3)) + log(c(c(3)))
4
store 7 – log(c(0)) + 3bin=111
V1.1 – 53/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
Złożoność obliczeniowa RAM
Złożoność obliczeniową RAM można łatwo określić jako sumę kosztów wszystkich wykonanych instrukcji w danym programie Π. Natomiast złożoność pamięciową, czyli jaki obszar pamięci RAM został wykorzystany podczas pracy programu można zapisać w następujący sposób: X max log(|c(i)|), PC
i
gdzie PC to licznik instrukcji w maszynie RAM. Przykładowo realizacja funkcji nn dla maszyny RAM posiada następujące złożoności: 1
O(n2 log n) – złożoność czasowa,
2
O(n log n) – złożoność pamięciowa.
V1.1 – 54/ 55
Wprowadzenie
Modele obliczeń
Maszyny proste
Już za tydzień na wykładzie
W następnym tygodniu między innymi:
1
Maszyna Turinga
2
Uniwersalność maszyny Turinga
3
Rachunek lambda
4
Logika i liczby w rachunku lambda
5
Rekurencja w rachunki lambda – punkty stałe
6
Kombinatory
Dziękuje za uwagę!!!
V1.1 – 55/ 55
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Modele algorytmiczne Maszyna Turinga, Rachunek Lambda Osoba prowadząca wykład i ćwiczenia: dr inż. Marek Sawerwain Instytut Sterowania i Systemów Informatycznych Uniwersytet Zielonogórski e-mail :
[email protected] tel. (praca) : 68 328 2321, pok. 328a A-2, ul. prof. Z.Szafrana 2, 65-246 Zielona Góra
Ostatnia zmiana: 21.11.2012
V1.0 – 1/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Spis treści 1
Wprowadzenie Plan wykładu
2
Maszyna Turinga Podstawowe informacje Definicja MT Reprezentacja MT Przykłady Kilka definicji Złożoność obliczeniowa MT Hipoteza Churcha-Turinga
3
Rachunek lambda Redukcje i konwersje Twierdzenie Churcha-Ressera Siła wyrazu λ-rachunku Logika Pary, listy, krotki Liczby naturalne Operator punktu stałego
4
Już za tydzień na wykładzie
V1.0 – 2/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Plan wykładu
Plan wykładu – spotkania tydzień po tygodniu
(1) Informacje o wykładzie, poprawność algorytmów (2) Poprawność algorytmów – logika Hoarego (3) Analiza złożoności kodu wysokiego i niskiego poziomu (4) Modele algorytmiczne – maszyny proste, obwody logiczne (5) ⇒ Modele algorytmiczne – maszyna Turinga oraz rachunek-λ ⇐ (6) Automaty – deterministyczne (7) Automaty – niedeterministyczne (8) Gramatyki – regularne i bezkontekstowe
V1.0 – 3/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Plan wykładu
Plan wykładu – spotkania tydzień po tygodniu
(9) Gramatyki i automaty ze stosem (10) Algorytmy równoległe (11) Klasy złożoności obliczeniowej (12) Pamięć logarytmiczna i wielomianowa (13) Problemy NP-zupełne (14) Wstęp do obliczeń kwantowych (15) Wybrane algorytmy kwantowe
V1.0 – 4/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Plan wykładu
Plan wykładu
1
Maszyna Turinga (MT) 1 2 3 4
2
opis maszyny definicja formalna realizacje algorytmów dla maszyny Turigna modyfikacje MT
Rachunek lambda (λ-rachunek) 1 2 3 4 5
definicja lambda rachunku podstawowe typy danych, liczebniki przykłady punkty stałe silnia
V1.0 – 5/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Plan wykładu
Materiały wykorzystane podczas tworzenia tego wykładu, a także przydatne do dalszych studiów: 1
S.W.Jabłoński, Wstęp do matematyki dyskretnej, Wydawnictwo Naukowe PWN, Warszawa 1991,
2
Harel D., Rzecz o istocie informatyki, WNT, 2000,
3
materiały do rachunku lambda, opracowane przez P.Urzyczyna: http://www.mimuw.edu.pl/~urzy/Lambda/, dokument autorów Henk Barendregt oraz Erik Barendsen, "Introduction to Lambda Calculus", http://www.cse.chalmers.se/research/ group/logic/TypesSS05/Extra/geuvers.pdf,
4
5
W. Kluge, Abstract Computing Machines, A Lambda Calculus Perspective, Springer Berlin Heidelberg New York, 2005,
6
i na przykład materiały do wykładu „Introduction to Theory of Computing”: http://www.ugrad.cs.ubc.ca/~cs421/ .
V1.0 – 6/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Maszyna Turinga
V1.0 – 7/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Podstawowe informacje
Maszyna Turinga – luźne dygresje Kilka dygresji na początek: Maszyna Turinga (1936, w skr. M.T.) jest uważana za jedno z ważniejszych odkryć XX wieku. M.T. Bezpośrednio przyczyniło się do stworzenia podstawy informatyki teoretycznej. Maszyna Turinga to nieskomplikowany ale bardzo użyteczny model obliczeń, jego ogólność jest wystarczająca aby reprezentować dowolny program komputerowy. Dzięki nieskomplikowanemu opisowi oraz prostych reguł funkcjonowania maszyna Turinga stanowi podstawę do dalszych matematycznych rozważań, które doprowadziły do lepszego zrozumienia problemów dotyczących pojęcia obliczeń. Z M.T. związane jest jedno z ważniejszych odkryć w teorii obliczeń, a jest to fakt iż istnieją problemy obliczeniowe, które nie mogą zostać rozwiązane na komputerze, niezależnie od ilości dostępnej pamięci oraz czasu. V1.0 – 8/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Definicja MT
Maszyna Turinga – definicja Maszyna Turinga została opracowana przez Alana Turinga w 1936 roku. Maszyna znajduje zastosowanie w roli notacji notacja do zapisu oraz wyrażania algorytmów. Możną ją także zastosować do określenia, które problemy są możliwe do rozwiązania.
Maszyna Turinga jest zbudowana z następujących elementów: 1
nieograniczonej taśmy z wydzielonymi komórkami, gdzie są zapisane zrozumiałe dla maszyny symbole,
2
głowicy, która może się przesuwać po taśmie w dwóch kierunkach: w lewo bądź w praco oraz odczytywać i zapisywać na niej symbole ze wskazanego zbioru symboli.
3
mechanizmu sterującego, który może być w różnych stanach (ale skończenie wielu), który decyduje o działaniu maszyny. Na podstawie bieżącego stanu i symbolu znajdującego się pod głowicą podejmuje decyzje o: 1 zmianie zawartości komórki taśmy znajdującej się pod głowicą. 2 przesunięciu głowicy w lewo lub w prawo. Ponieważ taśma jest nieograniczona (czyli potencjalnie nieskończona), zawsze można wykonać przesunięcie. 3 zmianie stanu mechanizmu sterującego.
V1.0 – 9/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Definicja MT
Maszyna Turinga – definicja formalna Formalna definicja maszyny Turinga: Maszyna Turinga M, to krotka o postaci: M = (Q, Σ, Γ, #, δ, q0 , F ), gdzie: Q to skończony zbiór stanów, Σ reprezentuje zbiór symboli wejściowych, które służą do reprezentacji wejścia maszyny i znajdują się na taśmie przed rozpoczęciem pracy maszyny, Γ to skończony zbiór symboli taśmowych - wszystkie symbole jakie mogą się znajdować na taśmie, i naturalnie Σ ⊆ Γ, # to symbol pusty - specjalny symbol taśmowy nie należący do symboli wejściowych (początkowo symbol pusty wypełnia wszystkie nie używane pola taśmy), δ – funkcja przejścia, funkcja częściowa prowadząca z Q × Γ w Q × Γ × {←, →}. Wartość δ(A, x) = (B, y , K ) oznacza, że maszyna będąca w stanie A i odczytująca symbol x z taśmy przejdzie do stanu B, po czym symbol y zostanie zapisany na taśmie a głowicę zostanie przesunięta o jedną komórkę w lewo (K =←) bądź w prawo (K =→), q0 to stan początkowy, w jakim znajduje się maszyna przed rozpoczęciem pracy, F to zbiór stanów akceptujących będący podzbiorem Q. Praca maszyny zakończy się poprawnie, kiedy osiągnięty zostanie stan ze zbioru F . V1.0 – 10/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Definicja MT
Słowny (i nie tylko) opis działania maszyny Turinga Opis działania maszyny Turinga w czterech punktach: 1
Zakłada się iż na taśmie wypełnionej symbolami pustymi (oznaczanymi przez #) znajduje się słowo wejściowe składające się z symboli wejściowych.
2
Następnie należy ustawić głowicę nad wybraną komórką taśmy. Można założyć iż głowicę ustawiono nad pierwszą komórką słowa wejściowego. Drugi element, to ustawienie mechanizmu sterującego na stan początkowy i można wprawić maszynę w ruch ;-).
3
Maszyna będzie działać zgodnie z wartościami tzw. funkcji przejścia – będzie zmieniać swój stan, przesuwać głowicę (w lewo bądź w prawo), a następnie zmieniać zawartość taśmy.
4
Gdy maszyna znajdzie się w stanie akceptującym, to obliczenia zakończyły się pomyślnie. Jeśli maszyna znajdując się w stanie A przeczyta z taśmy symbol s, a wartość funkcji przejścia nie będzie zdefiniowana, to w takim przypadku, obliczenia zakończy się błędem.
Ważna uwaga: istnieje możliwość, iż warunki zakończenia nie pojawią się, w takim wypadku maszyna nie kończy obliczeń. V1.0 – 11/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Reprezentacja MT
Reprezentacja maszyny Turinga
Można przedstawić dwa sposoby reprezentacji maszyny Turinga: 1
2
Pierwszy wykorzystuje tabele opisująca postać funkcji przejścia δ. W kolejnych wierszach umieszcza się ciągi S1 , l1 : S2 , l2 , D oznaczające δ(S1 , l1 ) = S2 , l2 , D. Symbole z taśmy li są reprezentowane przez symbole występujące w tabelce. A symbolu pusty jest oznaczany jako #. Stany maszyny to symbole Sj , a akceptujące mogą być oznaczone innym kolorem bądź pogrubione. Symbol D to kierunek przesunięcia głowicy. Można też przedstawić maszynę w postaci diagramu, czy raczej grafu skierowanego. Każdy ze stanów maszyny jest reprezentowany przez wierzchołek. A stany końcowe to stany, dla których nie ma krawędzi wychodzących.
V1.0 – 12/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Przykłady
Maszyna Turinga – dodawanie liczb unarnych Na taśmie umieszczono dwie liczby naturalne n i m zapisane w kodzie unarnym i są oddzielone pojedynczym zerem. Po zakończeniu działania na taśmie powinna być zapisana liczba n + m. Językiem wejściowym maszyny będzie Σ = {0, 1}. Maszyna posiada cztery stany Q = {q0 , q1 , q2 , q3 }, stanem początkowym jest q0 , a stanem akceptującym q3 . (0, 1, R) (1, 1, R)
q0 (#, #, L) q1 (1, #, L) q2 (1, #, L)
q3
Tabela przejść dla maszyny Turinga: q_0,0 q_0,1 q_0,# q_1,1 q_2,1
; ; ; ; ;
q_0,1, q_0,1 q_1,# q_2,# q_3,#
R R L L R V1.0 – 13/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Przykłady
Maszyna Turinga – palindrom a/a, R b/b, R a/#, L
#/#, L test a
move a a/#, R
b/b, L
#/#, L
a/a, L mark
#/#, L
yes
no #/#, L
return
b/b, L
a/a, L
b/#, R b/#, L #/#, L move b
test b
a/a, R b/b, R #/#, P
Maszyna wykrywająca, czy słowa zbudowane z symboli a oraz b tworzą palindrom.
V1.0 – 14/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Przykłady
Maszyna Turinga – język L = ai bi , i ≥ 0 Maszyna Turinga rozpoznająca język L = ai b i , i ≥ 0. Opis działania można przedstawić w następujący sposób (zakładamy że ciąg na taśmie to „aaabbb”): odczytanie pierwszego symbolu a, i jego zamiana na X , przesunięcie głowicy w prawo na koniec słowa i zamiana symbolu b na # znajdującego się przed znakiem #, aaabbb## ⇒ Xaabb### cofnięcie się do symbolu a, i powtórzenie poprzedniej operacji: Xaabb### ⇒ XXab#### kolejny krok: XXab#### ⇒ XXX ##### po tych operacjach mamy tylko symbole X oraz #. Jeśli ciąg początkowy zawierał taką samą ilość a oraz b to rezultatem będzie taśma wypełniona tylko symbolami pustymi oraz symbolami X , co wystarczy do stwierdzenia, że słowo należy do L. V1.0 – 15/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Przykłady
Maszyna Turinga – język L = ai bi , i ≥ 0 Formalny opis maszyny, niech M = (Q, Σ, Γ, #, q0 , δ, F ) gdzie q0 jest stanem startowym, zbiory Q = {q0, q1, q2, q3, q4}, Σ = {a, b}, Γ = {a, b, X , #} (ponieważ Σ ⊂ Γ) oraz δ jest określona jak poniżej: δ(q0 , a) = (q1 , X , R), pierwsze a zastąpione przez X , δ(q1 , a) = (q1 , a, R) oraz δ(q1 , b) = (q1 , b, R), ominięcie pozostałych a i b oraz przesunięcie się w prawo do napotkania #, ?δ(q1 , #) = (q2 , #, L), odszukanie symbolu b, δ(q2 , b) = (q3 , #, L), symbol b zastąpiony przez # i przesunięcie w lewo, δ(q3 , b) = (q3 , b, L) oraz δ(q3 , a) = (q3 , a, L), ominięcie pozostałych a i b, przesunięcie w lewo i osiągnięciu symbolu X , δ(q3 , X ) = (q0 , X , R), X zastępuje X i przesunięcie w prawo, δ(q0 , #) = (q4 , #, R), pozostawienie #. Ostatecznie F = {q4 }, jeśli maszyna zatrzyma się w innym stanie, słowo nie należy do L. (a, a, R) (b, b, R)
q0 (a, X, R)
q1
(a, a, L) (b, b, L)
(#, #, L) q (b, #, L) 2
q3
(#, #, R) (X, X, R)
q4 V1.0 – 16/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Przykłady
Maszyna Turinga – język L = ai bi , i ≥ 1 Konstrukcja M.T. rozpoznającej język L = ai b i , i ≥ 1 opiera się na nieco innym pomyśle, należy pamiętać że maszyna nie potrafi liczyć, więc trzeba odszukiwać pary liter a oraz b wg następujących kroków: zamiana symbolu a przez X i przesuniecie się do pierwszej litery b i jej zamiana na symbol Y , cofnięcie się i odszukanie kolejnej litery a i powtórzenie powyższego kroku, zadanie rozpoznania słowa zostanie zakończone poprawnie, gdy symbole X poprzedzają symbole Y . (a, a, R) (Y, Y, R)
q0 (a, X, R)
(Y, Y, R)
(Y, Y, R)
q1
(b, Y, L)
(a, a, L) (Y, Y, L)
q2
(X, X, R)
q3
(#, #, R)
q4 V1.0 – 17/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Przykłady
− − Maszyna Turinga – język L = → w← w
Przykład z „Ważniaka”, tabela z funkcją δ: A, A, A, B, B,
0 1 # 0 1
: : : : :
B, C, G, B, B,
#, #, #, 0, 1,
R R R R R
B, C, C, C, D,
# 0 1 # 0
: : : : :
D, C, C, E, F,
#, 0, 1, #, #,
L R R L L
E, F, F, F,
1 0 1 #
: : : :
F, F, F, A,
#, 0, 1, #,
L L L R
Wykorzystujemy pomysł z maszyny z palindromami, wyraz który rozpoczyna się od symbolu a, kończy się także symbolem a.
V1.0 – 18/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Przykłady
− − Maszyna Turinga – język L = → w← w Przykład z „Ważniaka”, diagram maszyny: (0, 1, R) (#, #, R) (1, 1, R) (0, 0, R)
A (0, #, R) B (#, #, L) D (#, #, R)
G
(0, #, L)
(1, #, R)
F B
(#, #, L)
D
(1, 1, L) (0, 0, L)
(1, #, L)
(1, 1, R) (0, 0, R)
I to jest maszyna do wykrywania palindromów, o innej niż poprzednio postaci.
V1.0 – 19/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Kilka definicji
Rozpoznawanie języka Językiem maszyny M nazwiemy L(M) ⊆ Σ∗ zbiór tych słów wejściowych, dla których obliczenie maszyny M kończy się w stanie akceptującym. Inaczej mówiąc określona M rozpoznaje język L(M). Język rekurencyjnie przeliczalny Język L ⊆ Σ∗ nazywamy rekurencyjnie przeliczalnym, albo częściowo rozstrzygalnym, jeżeli istnieje taka maszyna M, że L = L(M). Pojęcie częściowej rozstrzygalność jest określane w sposób następujący, jeżeli dane słowo w jest akceptowalne, to w ∈ L o maszyna zakończy swoje działanie. W przypadku, jeśli słowo w 3 L, to obliczenia mogą się nie zakończyć. MT ma własność stopu, jeżeli dla dowolnego słowa w ∈ Σ∗ obliczenie MT na w się kończy. Język L ⊆ Σ∗ nazywamy rekurencyjnym, lub rozstrzygalnym, jeżeli istnieje maszyna Turinga M z własnością stopu taka, że L = L(M). V1.0 – 20/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Kilka definicji
− − Poprawność MT dla L = → w← w Stanem akceptującym MT jest stan G , a jedyne przejście do stanu G pochodzi ze stanu A dla symbolu pustego #. Ponieważ stan A jest stanem początkowym, oznacza to, że aby maszyna zaakceptowała niepuste słowo x musi ona powrócić jeszcze choć raz do stanu A. Analiza przejść umożliwiających powrót do stanu A pozwala stwierdzić, że maszyna akceptuje słowa postaci: x jest słowem pustym, x = 0y 0 lub x = 1y 1, gdzie MT akceptuje słowo y . Należy przeprowadzić dowód indukcyjny ze względu na długość słowa x. Zakładając, że x należy do języka maszyny wtedy i tylko wtedy, gdy x = → − − dla pewnego w . w← w Dla długości równej 0 teza jest trywialna. Krok indukcyjny dowodzi się dla x o długości większej od zera. Słowo x należące do języka maszyny nie jest − zatem słowem pustym i jest postaci 0y 0 lub 1y 1, a y jest postaci → v← v−. To −−→←−− −−→←−− z kolei jest równoważne x = (0v )(0v ) lub x = (1v )(1v ). V1.0 – 21/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Złożoność obliczeniowa MT
Zasoby obliczeniowe dla Maszyny Turinga
Liczba kroków Czas obliczenia MT dla słowa wejściowym w oznaczamy przez T (M, w ) i jest to liczba kroków wykonanych nim MT się za trzyma. Jeżeli M nigdy się nie zatrzyma, to czas obliczeń jest nieskończony i zapisujemy to jako T (M, w ) = ∞. Czas działania MT jest definiowany w następujący sposób. Złożoność czasowa Funkcja f : N → N jest złożonością czasową dla maszyny M, jeżeli ∀n∈N : f (n) = max{T (M, w ) : w ∈ Σn }.
V1.0 – 22/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Złożoność obliczeniowa MT
Zasoby obliczeniowe dla Maszyny Turinga Pamięć Pamięć potrzebną do obliczeń realizowanych przez MT na słowie w – S(M, w ) jest definiowana jako liczba komórek taśmy, które zostały odwiedzone przez głowicę w trakcie pracy. Jeżeli M nie zatrzymuje się na w , to wartość S(M, w ) jest nieokreślona. Złożoność pamięciowa Mówimy, że funkcja f : N → N jest złożonością pamięciową maszyny M z własnością stopu, jeżeli ∀n∈N : f (n) = max{S(M, w ) : w ∈ Σn }.
MT dodająca → − MT − w← w
Złożoność czasowa f (0) = 1 f (1) = 3 f (n) = n + 3; n ≥ 2 f (n) = 6 + 8 + . . . + (n + 3) + 2; n = 2k + 1 f (n) = 5 + 7 + . . . + (n + 3) + 1; n = 2k
Złożoność pamięciowa f (0) = 2 f (1) = 3 f (n) = n + 1; n ≥ 2 f (n) = n + 1
V1.0 – 23/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Złożoność obliczeniowa MT
„Ważniakowe” uwagi do poprzedniego slajdu Aby określić złożoność czasową i pamięciową maszyny dodającej należy zauważyć, że maszyna czytając dowolny ciąg n zer i jedynek przesunie się dokładnie n razy w prawo (dochodząc do n + 1 pozycji na której jest zero), a potem cofnie się co najwyżej trzy razy (w przypadku jeśli są dwie jedynki na końcu). Ponieważ dla słów krótszych niż dwu znakowe niemożliwe są dwie jedynki na końcu, a możliwe jest wycofanie głowicy przed słowo wejściowe - należy te przypadki rozważyć osobno. ??? → − jest prostsza, ponieważ nie występują przypadki Analiza maszyny rozpoznającej język − w← w brzegowe. Złożoność pamięciowa wynosi n + 1, gdyż maszyna używa zawsze dokładnie n + 1 komórek taśmy. ??? Złożoność czasowa wynika w rekurencyjnego wzoru f (n) = n + 3 + f (n − 2) oraz f (0) = 1if (1) = 2. Rozwiązaniem rekurencji dla n ≥ 2jest: f (n) =
n−1 n+3 (6 + ) dla n = 2k + 1 2 2 n n+3 f (n) = (5 + ) dla n = 2k 2 2 V1.0 – 24/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Hipoteza Churcha-Turinga
Hipoteza Churcha-Turinga Alonzo Church oraz Alan Turing w roku 1936 zaproponowali niezależnie od siebie dwa rożne modele obliczeń. A.Church zaproponował rachunek lambda natomiast A.Turing abstrakcyjną maszynę, którą później nazwano maszyną Turinga. Pomimo zasadniczych różnic pomiędzy formalizmami maszyny Turinga oraz λ-rachunku, A.Turing udowodnił iż są one równoważne. Dowód A.Turinga został przeformułowany przez Stephena Kleenego w 1943, w następujący wniosek: Każdy problem, który może być intuicyjnie uznany za obliczalny, jest rozwiązywalny przez maszynę Turinga. Wniosek ten jest również nazywany hipotezą (albo tezą) Churcha-Turinga. Niestety pojęcie „intuicyjnie uznany” utrudnia przeprowadzenie formalnego dowodu matematycznego. Istnieją także odmiany tezy Churcha-Turinga: Każdy problem, który jest fizycznie obliczalny również może zostać rozwiązany za pomocą maszyny Turinga. Każdy „rozsądny” model obliczeń może być zasymulowany w sposób efektywny na probabilistycznej Maszynie Turinga.
V1.0 – 25/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Hipoteza Churcha-Turinga
Modyfikacje maszyn Turinga
Pomimo różnych modyfikacji, dodawanie dodatkowych taśm, dodatkowe głowić, czy zmiana opisu funkcji przejścia: 1
maszyny Turinga z wieloma niezależnymi głowicami,
2
maszyny Turinga z wieloma taśmami,
3
maszyny Turinga z taśmą dwuwymiarową,
4
niedeterministyczne maszyny Turinga,
5
probabilistyczne maszyny Turinga,
6
kwantowe maszyny Turinga,
wszystkie wymienione maszyny Turinga są sobie równoważne.
V1.0 – 26/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Hipoteza Churcha-Turinga
Modyfikacje maszyn Turinga
Możliwe jest także wprowadzanie różnych ograniczeń, jak np.: 1
maszyny Turinga z jednostronnie ograniczoną taśmą,
2
maszyny Turinga nad alfabetem binarnym,
3
maszyny Turinga o dwóch stanach,
4
maszyny Turinga, które nigdy nie zmieniają już zapisanych symboli, maszyny Turinga, dla których poprzedni stan może być jednoznacznie wyznaczony przez stan bieżący oraz oraz przez zawartość taśmy,
5
wszystkie wymienione maszyny Turinga także są sobie równoważne.
V1.0 – 27/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Hipoteza Churcha-Turinga
Kompletność maszyny Turinga Kompletność (zupełność) w sensie Turinga oznacza iż jeśli w danym modelu, można rozwiązać pewną klasę problemów obliczeniowych, to można owe problemy rozwiązać także za pomocą MT. W praktyce oznacza to, że jeśli dany język lub maszyna potrafi wykonać pewny algorytm, określany mianem zupełnego, to algorytm ten będzie można zrealizować w innym modelu obliczeniowych. Jednakże nie jest wymagane, aby algorytm posiadał prostą reprezentację w innym modelu, czy też jego realizacja była wydajna oraz efektywna w środowisku innego mechanizmy obliczeniowego. Przykładowe modele zupełne: maszyna Turinga rachunek lambda system półthueowski (ang. Semi-Thue system, string rewriting system) Następujące języki programowania są zupełne w sensie Turinga: języki proceduralne, np. C, Pascal języki obiektowe, np. Java, C# języki wieloparadygmatowe, np. Ada, C++, Common Lisp języki funkcyjne, np. Haskell, Ocaml, F# języki logiczne, Prolog języki deklaratywne, XSLT V1.0 – 28/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Rachunek lambda
V1.0 – 29/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Rachunek lambda W latach trzydziestych XX wieku Alonzo Church oraz Haskell Curry, pracując niezależnie, zaproponowali notację dla funkcji tzw. rachunek lambda. Zastosowanie funkcji w rachunku lambda jest nieco inne od klasycznego rozumienia funkcji (sensie teoriomnogościowego) jako zbioru par argument oraz wartość. W rachunku lambda w funkcji podkreśla się obliczalność funkcji, bowiem to treść funkcji decyduje o obliczeniach. Rachunek lambda ma dwa podstawowe warianty: typowany oraz nietypowany.
Pojawiło się także nowe wydanie, Henk Barendregt, The Lambda Calculus. Its Syntax and Semantics, College Publications, 2012.
V1.0 – 30/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Rachunek lambda Zbiór λ-wyrażeń (określany jako zbiór Λ) jest zbudowany z użyciem zbioru zmiennych V = {v , v 0 , v 00 , . . .} oraz dwóch pojęć aplikacji oraz abstrakcji: x ∈V M, N ∈ Λ M ∈ Λ, x ∈ V
⇒ ⇒ ⇒
x ∈Λ (MN) ∈ Λ (λxM) ∈ Λ
Wyrażenia rachunku lambda są tworzone w następujący sposób (reguły zapisane w postaci gramatyki bezkontekstowej – notacja BNF): 1: 2: 3:
< λ − wyr >
::=< zmienna > | (< λ − wyr 1 >< λ − wyr 2 >) | (λ < zmienna > . < λ − wyr >)
Nawiasy są pomijane wg zasady łączności lewostronnej np.: MNPQ ≡ (((MN)P)Q). Wieloargumentowe funkcje są reprezentowane przez funkcje jednoargumentowe, których argumentami są funkcje. Zatem wyrażenie w postaci F (N, M), w rachunku lambda zapisuje się ((FN)M) ≡ FNM. Powtórzenia symbolu λ pomijane są wg łączności prawostronnej, tzn. λxyz.M ≡ (λx.(λy .(λz.M))).
V1.0 – 31/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Lambda wyrażenie jako rysunek Przykładowe lambda wyrażenie:
V1.0 – 32/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Długość lambda wyrażenia Długość dowolnego wyrażenia oznacza się identycznie jak wartość bezwzględną: |M|. Stosuje się trzy reguły do wyznaczania długości wyrażeń podstawowych. Długość zmiennej to: def
|x| = 1. Długość zastosowania jest równa długości poszczególnych wyrażeń: def
|(W1 , W2 )| = |W1 | + |W2 |. Długością lambda abstrakcji jest suma jedności oraz długość wyrażenia W : def
|(λx.W )| = 1 + |W |. Przykład wyznaczenia długości lambda wyrażenia jest następujący: |(λx.xy )(λz.x)(λy .y )| = |λx.xy | + |λz.x| + |λy .y | = 1 + |xy | + 1 + |x| + 1 + |y | = 1 + |x| + |y | + 1 + 1 + 1 + 1 =1+1+1+1+1+1+1=7 V1.0 – 33/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Zmienne wolne Zmienne wolne, to zmienne nie związane, czyli takie dla których nie została zastosowana λ-abstrakcja. Podobnie jak przy pojęciu długości również w zamiennych wolnych pojawiają się trzy definicje. Pierwsza wskazuje że zmienną wolną jest pojedyncze wystąpienie zmiennej: def
FV [x] = {x}. Druga postać oznacza, że zmiennych wolnych należy szukać oddzielnie dla każdego wyrażania: def FV [W1 ; W2 ] = FV [W1 ] ∪ FV [W2 ]. Trzecia definicja wyklucza ze zbioru zmiennych wolnych zmienną co do której zastosowano związanie: def
FV [λx.W ] = FV [W ]\{x} Przykład wyznaczania zmiennych wolnych: FV [x(λxy .xz)] = FV [x] ∪ FV [λxy .xz] = {x} ∪ (FV [xz]\{x, y }) = = {x} ∪ ((FV [x] ∪ FV [z])\{x, y }) = {x} ∪ (({x} ∪ {z})\{x, y }) = {x, z} Definicja Termem domkniętym, nazywamy term bez zmiennych wolnych: FV (T ) = ∅. Term domknięty, określa się również mianem kombinatora. V1.0 – 34/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Zmienne związane oraz podtermy Analogicznie za pomocą podobnych wyrażeń jak dla FV można podać definicję zbioru zmiennych związanych. Tym razem stosuje się oznaczenie BV od ang. słów bound variables. Wolne wystąpienie zmiennej, naturalnie nie należy do zbioru zmiennych związanych: BV [x] = ∅ Wyznaczanie zmiennych zwiazanych dla dwóch lambda wyrażeń, czyli zastosowania identycznie jak przy zmiennych wolnych polega na oddzielnej analizie wyrażeń: def
BV [W1 ; W2 ] = BV [W1 ] ∪ BV [W2 ] Zmienna związana lambda–abstrakcją naturalnie należy do zbioru zmiennych związanych: def
BV [λx.W ] = BV [W ] ∪ x Podtermy są wyznaczane przy pomocy funkcji S. Funkcja przyjmuje następującą postać podobną do definicji podanych wcześniej funkcji FV oraz BV : def
S[x] = {x} , def
S[(W1 W2 )] = S[W1 ] ∪ S[W2 ] ∪ {(W1 W2 )} , def
S[(λx.W )] = S[W ] ∪ {(λx.W )} . V1.0 – 35/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Funkcja podstawienia Oznaczenie podstawienia pojawia się w dwóch postaciach: M[N/x], co oznacza że w wyrażeniu M, w miejscu wystąpień zmiennej x zostanie wstawione wyrażenie N. Druga postać jest następująca: M[x := N]. W tej operacji trzeba jednak zwrócić uwagę na to, że nie podstawiamy tylko pod zmienne wolne ale i związane, co może powodować kolizje w nazwach zmiennych. Należy w takim przypadku zmienić nazwy. Dokładna definicja uwzględniająca poszczególne przypadki jest następująca: x[N/x] y [N/x] (P Q)[N/x] (λx.P)[N/x] (λy .P)[N/x] (λy .P)[N/x] (λy .P)[N/x]
= = = = = = =
N y P[N/x] Q[N/x] λx.P λy .P λy .P[N/x] λz.P[z/y ][N/x]
y 6= x
x y y z
∈ / FV (λy .P) , x = y 6= x ∈ FV (P) , y ∈ / FV (N) 6= x ∈ FV (P) , y ∈ FV (N) jest nową zmienną
Przykład podstawienia, gdy nie występuje kolizja jest trywialny: ((λy .xy )x)[z/y ] = ((λz.xz)x) Ten sam przykład, ale z kolizją wymaga skorzystania z ostatniej definicji podstawienia: ((λy .xy )x)[y /x] = ((λv .yv )y ) V1.0 – 36/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Redukcje i konwersje
Relacja pomiędzy wyrażeniami i α-konwersja Relację pomiędzy wyrażeniami w λ-rachunku nazywa się kongruencją. Relację oznacza się symbolem ∼ i ma ona następujące własności: relacja ∼ jest zwrotna, symetryczna i przechodnia (równoważność), 0
0
0
0
jeśli M ∼ M i N ∼ N to MN ∼ M N , 0
0
jeśli M ∼ M to λx.M ∼ λx.M . Relacją alfa–konwersji (α-konwersji) jest najmniejsza relacja równoważności (oznaczana α
jako ≡) w zbiorze wyrażeń spełniająca poniższy warunek: α
λx.M ≡ λy .[y /x]M dla dowolnego y ∈ / FV [M] O α–konwersji można też powiedzieć, że jest to operacja zmiany nazwy zmiennej. α 0 Co jest związane z następującym faktem: M ≡ M ⇔ M ≡ M0 , M1 , M2 , . . . , Mn ≡ 0 M , czyli Mi −1 różni się od Mi (gdzie i = 1, . . . , n) tylko nazwą zmiennej związaα
nej. Prawdziwe będą też następujące warunki: jeśli M ≡ M α α 0 0 MP ≡ M P ∧ PM ≡ PM dla dowolnego P. Z tej definicji wynikają następujące własności α–konwersji:
0
α
to λx.M ≡ λx.M
0
oraz
α
jeśli M ≡ N to |M| = |N| oraz FV [M] = FV [N], 0
α
0
0
dla dowolnego M istnieje M czyli M ≡ M i w M nie występują kolizje zmiennych. V1.0 – 37/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Redukcje i konwersje
Pojęcie redukcji Przykład operacji redukcji, gdzie stosowane są reguły dodawania i mnożenia: (12 + 2) ∗ (8 − 4 ∗ 3) → → → →
14 ∗ (8 − 4 ∗ 3) 14 ∗ (8 − 12) 14 ∗ (−4) −56
Przykład operacji redukcji dla operacji na symbolach, w tym konkretnym przypadku na ciągach znaków: first-of(sort(append(0 dog 0 ,0 rabbit 0 ) (sort((0 mouse 0 ,0 cat 0 ))))) → → first-of(sort(append(0 dog 0 ,0 rabbit 0 ) (0 cat 0 ,0 mouse 0 ))) → first-of(sort(0 dog 0 ,0 rabbit 0 ,0 cat 0 ,0 mouse 0 )) → first-of(0 cat 0 ,0 dog 0 ,0 mouse 0 ,0 rabbit 0 ) →0 cat 0 Przykłady pochodzą z Henk Barendregt oraz Erik Barendsen, "Introduction to Lambda Calculus". V1.0 – 38/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Redukcje i konwersje
Beta redukcja Następną relacją w zbiorze Λ jest beta-redukcja (β-redukcja). Jest to najβ
mniejsza relacja oznaczana przez ≡ o następujących własnościach: β
(λx.M)N ≡ M[N/x] β
0
β
β
0
0
β
jeśli M ≡ M to MN ≡ M N, NM ≡ NM oraz λx.M ≡ λx.M
0
Relacja β-redukcja odgrywa najważniejszą rolę w przetwarzaniu wyrażeń w λ-rachunku, ponieważ pozwala na zastosowanie argumentów do funkcji. Przykład dla wyrażenia (λx.1 + x + 2 + x)5, po zastosowaniu β-redukcji otrzymamy wyrażenie: 1 + 5 + 2 + 5. Ważnym pojęciem jest domknięcie przechodnio-zwrotne podanej powyżej relacji, oznaczone jest jako: β
β
bądź
V1.0 – 39/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Redukcje i konwersje
Beta redukcja
Wyrażenie w postaci (λx.M)N nazywa się β-redex’em (ang. redex – reducible expression), czyli jest to wyrażenie dla którego można zastosować relację β-redukcji. Gdy w termie M, nie występuje żaden β-redex, to nie zachodzi β
relacja M ≡N. Oznacza to, że M jest w postaci β-normalnej (lub krócej w postaci normalnej). Istnieją wyrażenia nie posiadające postaci normalnej np.: β
β
(λx.xx)(λx.xx)≡(λx.xx)(λx.xx)≡ . . .
V1.0 – 40/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Redukcje i konwersje
Beta redukcja – jeszcze jeden przykład β-redukcja albo β-konwersja to procedura realizująca obliczenia wykonywane przez rachunek lambda poprzez proces zwany β-redukcją. Aplikujemy procedurę λx.M do argumentu N: (λx.M)N →β M[x/N] w taki sposób, że każda zmienna wolna termu N pozostaje wolna po podstawieniu. Jest to oczywiście możliwe do osiągnięcia po ewentualnym wcześniejszym zastosowaniu αkonwersji np.: (λxy .xy )y → λy .yy jest nieprawidłowym użyciem β-konwersji, gdyż dochodzi do konfliktu oznaczeń i do zniekształcenia pierwotnego znaczenia termu. Rozwiązaniem jest zastosowanie α-konwersji: (λxy .xy )y =α (λxz.xz)y =β λz.yz. Używamy oznaczenia T1 =β T2 , aby powiedzieć, że termy T1 i T2 są równe modulo β-konwersji, tzn. że mogą być zredukowane do tego samego termu dzięki zastosowaniu skończonej liczby β-konwersji.
V1.0 – 41/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Twierdzenie Churcha-Ressera
Twierdzenie Churcha-Ressera W jednym termie może naturalnie znajdować się więcej niż jeden β-redex. Oznacza to, że dane wyrażenie można redukować na więcej niż jeden sposób. Nie oznacza to, że można otrzymywać dwa różne ciągi, ponieważ istnieje tw. Churcha-Ressera o następującej treści: Twierdzenie β
β
Jeśli P M Q to P ↓β Q. Rysunek przedstawia postać twierdzenia Churcha-Rossera jako romb. Jest to również postać dowodu. Jeśli M można zredukować na dwa sposoby i wiadomo, że P i Q są w postaci normalnej, to istnieje T , które powstało na drodze α-konwersji.
V1.0 – 42/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Siła wyrazu λ-rachunku
Siła wyrazu λ-rachunku Rachunek lambda może wydawać się raczej prymitywnym narzędziem, gdzie można wyrażać tylko najprostsze, czy wręcz prymitywne elementy. Trudno, spoglądając tylko na składnię i operacje jakie można w ramach rachunku wykonywać, traktować λ-rachunek jako język programowania. Jednak siła lambda rachunku jest wystarczająca do realizacji konstrukcji wyższego poziomu choć nieco odmienna ponieważ nie występuje w nim rekurencja typowa dla znaczącej większości języków programowania. Jednakże, rachunek oferuje operatory punktu stałego znakomicie rozwiązujące ten brak. Wśród wielu oznaczeń na wyrażenia lambda rachunku niektóre są dość istotne, więc zostaną w tym miejscu wymienione: I K S ω Ω
def
=
λx.x
def
=
λxy .x
def
=
λxyz.xz(yz)
def
=
λx.xx
def
ωω
=
V1.0 – 43/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Logika
Siła wyrazu λ-rachunku – logika Definicja funkcji o n argumentach zawsze równa zeru (przy czym zero tratuje się tu w sposób tradycyjny) jest następująca: def
Zn = λm1 . . . mn .0. Funkcja rzutu n-argumentowego na k-tą współrzędną: def
πkn = λm1 . . . mn .mk . Podstawowymi definicjami są wartości logiczne prawda i fałsz. Mają one zastosowania w większości wyrażeń. I tak logiczną prawdę, definiuje się w następujący sposób: def
true = λxy .x . Natomiast definicja logicznego fałszu różni się jednym detalem: def
false = λxy .y . Główna idea tych wyrażeń, to oddawanie jako wyniku, pierwszego bądź drugiego argumentu. Jednak, w połączeniu z odpowiednio dobranymi definicjami innych operatorów, pojęcia te funkcjonują identycznie jak wyrażenia logiczne. Następnym operatorem jest operator warunkowy, odpowiednik instrukcji warunkowej (instrukcji selekcji): def
if = λbxy .bxy . V1.0 – 44/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Logika
Siła wyrazu λ-rachunku – logika Definicje true, false oraz if pozwalają na zdefiniowanie trzech podstawowych operatorów logicznych: not, and oraz or. Ich definicja przedstawia się następująco: def not = λb.if b false true and
def
=
λb1 b2 .if b1 b2 false
or
def
λb1 b2 .if b1 true b2
=
Przykład dla operatora or: or true false ≡ (λb1 b2 .if b1 true b2 ) true false β
β
≡ if true true false ≡ true Podstawowym elementem jest operator if oraz fakt, że wartości logiczne true oraz false pozwalają na selektywne wybieranie elementu. Odpowiednie ułożenie wartości logicznych powoduje, że stosowanie β-konwersji oznacza wybieranie właściwych wartości. V1.0 – 45/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Pary, listy, krotki
Pary, listy, krotki
W lambda rachunku można pokazać wiele definicji różnych pojęć. Jednym z przykładów są właśnie pary. Parę definiuje się, w oparciu o warunek. Wykorzystujemy fakt, że istnieje sposób na odwołanie się do pierwszego i drugiego elementu: def pair = λxyb.ifbxy Odczytanie owych elementów do zadanie funkcji fst i snd używają one jak widać wartości logicznych, które jak wcześniej podano przekazują w wyniku odpowiednio pierwszy bądź drugi argument (stanowią szczególną postać funkcji rzutu): fst
def
=
λp.p true
snd
def
λp.p false
=
V1.0 – 46/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Pary, listy, krotki
Pary, listy, krotki – przykłady
Przykład pierwszy „wyciągnięcie” z pary pierwszego elementu: fst(pairMN) ≡ λp.p true (pairMN) β
≡ pairMN true ≡ (λxyb.if bxy )MNtrue β
β
≡ if true MN ≡ M Przykład drugi „wyciągnięcie” z pary drugiego elementu: snd(pairMN) ≡ λp.p false (pairMN) β
≡ pairMN false ≡ (λxyb.if bxy )MNfalse β
β
≡ if false MN ≡ M
V1.0 – 47/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Pary, listy, krotki
Pary, listy, krotki Krotka, ta uogólnione pojęcie pary, bowiem dopuszcza się jej dowolną wielkość: def (M1 , M2 , . . . , Mn ) = λx.x M1 , M2 , . . . , Mn Wybór k-tego elementu z tak zdefiniowanej struktury (n-elementów, wybieramy k-ty element), polega na wykorzystaniu funkcji zrzutu: def
selnk = λp.p πkn Na podstawie par można zdefiniować ogólną n-elementową listę, bowiem jest ona zawsze reprezentowana w postaci par: def
(E1 , E2 , E3 , ..., En ) = (E1 , (E2 , (E3 , ( ... )En−1 )En )) Dla powyższego wyrażenia, po zastosowaniu funkcji fst otrzymamy E1 . Natomiast, dla snd wynikiem będzie cała struktura rozpoczynająca się od wyrażenia E2 . V1.0 – 48/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Pary, listy, krotki
Pary, listy, krotki
Oznacza to, że gdy chcemy otrzymać pierwszy element to należy zastosować funkcję fst, a ogólnie dla i-tego elementu wzór jest następujący: def
adr (E i) = fst(snd(snd(snd(...(snd E ))))) | {z } i−1 razy
W identyczny sposób zostało zrealizowane przetwarzanie typów listowych w języku LIST, za pomocą funkcji car oraz cdr.
V1.0 – 49/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Liczby naturalne
Siła wyrazu λ-rachunku – liczby naturalne Liczby naturalne są reprezentowane w postaci tzw. liczebników Churcha. Wzór na dowolną naturalną liczbę jest następujący: def
cn = λfx.f n (x) Zapis f n (x) należy rozumieć jako n-krotne zastosowanie funkcji f : f (f (f (· · · (x) · · · ))). Kilka pierwszych liczba naturalnych jest określonych w następujący sposób: def = λfx.x 0 1
def
=
λfx.fx
2
def
λfx.f (f x)
3 ...
def
= λfx.f (f (f x)) ... ...
n
def
=
=
λfx.f n x
Bardzo istotna uwaga: 1 =βη I ale 1 6=β I. V1.0 – 50/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Liczby naturalne
Liczby naturalne, następnik oraz poprzednik Na podstawie liczebników Churcha można wyprowadzić pojęcie następnika. Definiowane jest ono w następujący sposób: def
succ = λn.λfx.f (n f x) To nie jest jedyna możliwa definicja następnika, nieco inna jest następująca: λnfx.nf (fx). Następnik pozwala na definicję liczb naturalnych w sposób indukcyjny: 0 1 2 3 ...
def
=
def
=
def
=
def
= ...
λfx.x succ 0 succ 1 succ 2 ...
Zdefiniowanie poprzednika jest bardziej kłopotliwe gdyż trzeba opisać fakt wywołania pewnej funkcji n − 1 razy mniej. Definicja pomocnicza funkcji h: def
h = λp.pair(snd p)(succ(snd p)) Pozwala na podanie czytelnej definicji poprzednika w następujący sposób: def
pred = λn.fst(n h (pair 0 0)) V1.0 – 51/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Liczby naturalne
Liczby naturalne
Rozwinięcie dla liczby 2. 2 f x ≡ succ 1 f x ≡ λn.λfx.f (n f x) 1 f x β
β
≡ (λfx.f (1 f x)) f x ≡ f (1 f x) ≡ f (succ 0 f x) β
≡ f ((λn.λfx.f (n f x)) 0 f x) ≡ f ((λfx.f (0 f x)) f x) β
β
≡ f (f (0 f x)) ≡ f (f ((λfx.x) f x)) ≡ f (fx) Następny przykład pokazuje, co zostanie wyznaczone dla następnika zera: β
succ 0 ≡ (λn.λfx.f (nfx) 0 ≡ λfx.f (0 f x) β
η
α
≡ (λfx.f ((λfx.x) fx) ≡ λfx.fx ≡ λf .f ≡ λx.x ≡ Id
V1.0 – 52/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Liczby naturalne
Liczby naturalne
Ponieważ, zadaniem pred jest zawsze wyciągnięcie pierwszego elementu z pary, więc istotne są operację dokonywane za pomocą funkcji pomocniczej h. 2 h (pair 0 0) ≡ (λfx.f (fx)) h (pair 0 0) β
≡ h(h (pair 0 0)) β
≡ h((λp.pair(snd p)(succ (snd p)))(pair 0 0)) β
≡ h(pair 0 1) β
≡ (pair(snd(pair 0 1))(succ(snd(pair 0 1)))) ≡ pair 1 2
V1.0 – 53/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Liczby naturalne
Dodawanie i mnożenie Z pomocą następnika oraz poprzednika można zrealizować podstawowe operacje arytmetyczne. I tak dodawanie jest zdefiniowane w następujący sposób: def add = λkn.k succ n Mnożenie w lambda rachunku przedstawia się następująco: def
mult = λkn.k(add n) 0 Funkcje: dodawania, mnożenia oraz następnika są ściśle ze sobą powiązane, każda nie jako zawiera w sobie poprzednią, widać to szczególnie, gdy ich definicje będzie się podawać jawnie bez żadnych skrótów. Uzupełnieniem jest definicja potęgowania: succ
def
=
λnfx.f (nfx)
add
def
=
λmnfx.mf (nfx)
mult
def
=
λmnfx.m(nf )x
exp
def
λmnfx.mnfx
=
V1.0 – 54/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Liczby naturalne
Dodawanie przykład Operacja dodawania: ADD = λmnsx.(ms)(nsx), przykład: ADD 1 2 =
{[λm. (λn. (λsx. (ms)(nsx))]1}2
| dopisując nawiasy i λ
=β
[λn. (λsx. (2s)(nsx)]1
| m := 2
=β
λsx. (2s)(1sx)
| n := 1 | dopisując nawiasy i λ
=
λsx. (2s){[(λt. (λy . ty ))s]x}
=β
λsx. (2s)[(λy . sy )x]
| t := s
=β
λsx. (2s)(sx)
| y := x
=
λsx. {[λt. (λy .t(ty ))] s} (sx) | {z } |{z}
| dopisując nawiasy i λ
=β
λsx. (λy . s(sy ))(sx)
| t := s
=β
λsx. s(s(sx))
| y := sx
=
3
procedura licząca 2
„zero”
Przykład z „Ważniaka”.
V1.0 – 55/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Liczby naturalne
Mnożenie przykład Operacja dodawania: MULT = λmnsx.n(ms)x, przykład: {[λm. (λn. (λsx. n(ms)x))]2}2
| dopisując nawiasy i λ
=β
[λn. (λsx. n(2s)x)]2
| m := 2
=β
λsx. 2(2s)x
| n := 2
=
λsx. 2[(λt. (λy . t(ty ))) s]x | {z }
| dopisując nawiasy i λ
=β
λsx. 2[λy . s(sy )]x
| t := s
=
λsx. [λt. (λz.t(tz))] [λy .s(sy )] x | {z } | {z }
| dopisując nawiasy i λ
=β
λsx. (λz. [λy .s(sy )]([λy .s(sy )]z))x
| t := [λy .s(sy )]
=β
λsx. [λy .s(sy )]([λy .s(sy )]z)
| z := x
=β
λsx. s(s[s(sx)])
| y := s(sx)
=
4
MULT 2 2 =
procedura licząca 2
procedura licząca 2 dodawanie 2
V1.0 – 56/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Liczby naturalne
Funkcja silnia Zapis definicji w lambda rachunku, jak ogólnie sam lambda rachunek stał się wzorem dla języka Scheme. Definicja silni w tym języku przedstawia się następująco: (define silnia (lambda (n) (if (= n 0) 1 (* n (silnia (- n 1)))))) (display "Silnia 5=") (display (silnia 5)) Natomiast w Pascalu, ta funkcja przyjmuje następującą postać: function silnia(n : longint) : longint; begin if n=0 then silnia:=1 else silnia:=n*silnia(n-1); end; V1.0 – 57/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Operator punktu stałego
Operator punktu stałego Wprowadzenie operatora punktu stałego Y jest konieczne aby można było określać funkcje rekurencyjne. Operator punktu stałego to term, który dla dowolnego termu M daje jego punkt stały, tzn. YM =β M(YM). Należy wskazać, że term Y = λy .(λx.y (xx))(λx.y (xx)) jest oczekiwanym operatorem. Zachowanie się Y zaaplikowanego do dowolnego termu M jest następujące: (λy .(λx.y (xx))(λx.y (xx)))M
| z definicji Y
(λx.M(xx)) (λx.M(xx)) {z } |
| y := M
=β
M((λx.M(xx)) (λx.M(xx))) | {z }| {z }
| x := B
=β
M(YM)
| YM = (λx.M(xx))(λx.M(xx))
YM = =β
B
B
B
V1.0 – 58/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Operator punktu stałego
Silnia w λ-rachunku Na początek dwie proste definicje: def
sil = Y SIL Gdzie SIL, to właściwa definicja: def
SIL = λs.λn.if(iszero n) 1 (mult n(s (pred n))) Samą definicję silni można przekształcać zgodnie z równaniem punktu stałego: β
β
sil ≡ Y SIL ≡SIL (Y SIL) ≡ SIL sil Podane definicje pozwalają na wyznaczanie wartości tej rekurencyjnej funkcji opisanej, za pomocą funkcji punktu stałego np.: β
β
β
sil 0 ≡ SIL sil 0 ≡ if(izero 0) 1 (mult 0 (sil (pred 0))) ≡ 1 V1.0 – 59/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
Operator punktu stałego
Silnia w λ-rachunku Wyznaczenie wartości dla jedynki jest następujące: β
β
sil 1 ≡ SIL sil 1 ≡ if(izero 1) 1 (mult 1 (sil (pred 1))) β
β
≡ mult 1 (sil (pred 1)) ≡ mult 1 (sil 0) β
β
≡ mult 1 1 ≡ 1 Natomiast, wyznaczenie wartości dla dwójki wygląda tak: β
β
sil 2 ≡ SIL sil 2 ≡ if(izero 2) 1 (mult 2 (sil (pred 2))) β
β
≡ mult 2 (sil (pred 2)) ≡ mult 2 (sil 1) β
β
≡ mult 2 1 ≡ 2
V1.0 – 60/ 61
Wprowadzenie
Maszyna Turinga
Rachunek lambda
Już za tydzień na wykładzie
W następnym tygodniu między innymi
1
Definicja automatu
2
Własności automatów
3
Determinizm
4
Zastosowania automatów
5
Wyrażenia regularne
6
Czas na trochę praktyki: Ragel State Machine Compiler
Dziękuje za uwagę!!!
V1.0 – 61/ 61
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Automaty (nie)deterministyczne – część I Osoba prowadząca wykład i ćwiczenia: dr inż. Marek Sawerwain Instytut Sterowania i Systemów Informatycznych Uniwersytet Zielonogórski e-mail :
[email protected] tel. (praca) : 68 328 2321, pok. 328a A-2, ul. prof. Z.Szafrana 2, 65-246 Zielona Góra
Ostatnia zmiana: 03.12.2012
V1.1 – 1/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Spis treści 1
Wprowadzenie Plan wykładu
2
Słowa, języki, relacje Słowa Język Relacje
3
Automaty Zastosowanie automatów Funkcja przejścia Własności automatów Minimalizacja automatów
4
Ragel Możliwości pakietu Ragel Przykłady zastosowań
5
A za tydzień na wykładzie
V1.1 – 2/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Plan wykładu
Plan wykładu – spotkania tydzień po tygodniu
(1) Informacje o wykładzie, poprawność algorytmów (2) Poprawność algorytmów – logika Hoarego (3) Analiza złożoności kodu wysokiego i niskiego poziomu (4) Modele algorytmiczne – maszyny proste, obwody logiczne (5) Modele algorytmiczne – maszyna Turinga oraz rachunek-λ (6) ⇒Automaty (nie)deterministyczne – część I ⇐ (7) Automaty (nie)deterministyczne – część II (8) Gramatyki – regularne i bezkontekstowe
V1.1 – 3/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Plan wykładu
Plan wykładu – spotkania tydzień po tygodniu
(9) Gramatyki i automaty ze stosem (10) Algorytmy równoległe (11) Klasy złożoności obliczeniowej (12) Pamięć logarytmiczna i wielomianowa (13) Problemy NP-zupełne (14) Wstęp do obliczeń kwantowych (15) Wybrane algorytmy kwantowe
V1.1 – 4/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Plan wykładu
Plan wykładu 1
Słowa, Języki, Relacje 1 2
2
Automaty deterministyczne 1 2 3 4 5
3
podstawowe definicje własności relacji budowa automatu deterministycznego funkcja przejścia automat skończony dla dowolnego języka skończonego suma, product i dopełnienie automatu minimalizacja automatu
Automaty w praktyce 1 2 3 4
projekt Ragel przykład implementacji automatu funkcja atoi linia z parametrami
V1.1 – 5/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Plan wykładu
Materiały wykorzystane podczas tworzenia tego wykładu, a także przydatne do dalszych studiów: 1 John E.Hopcroft, Jeffrey D.Ullman: Wprowadzenie do teorii automatów, języków i obliczeń, Wydawnictwo Naukowe PWN 2003 Wydanie 1 oraz Wydanie 2 z roku 2006, 2
przedmiot Języki automaty i obliczenia z Ważniaka,
3
wykład M.Kubicy, Języki formalne i automaty, http://www.mimuw.edu.pl/~kubica/aug/index-frames.html,
4
Podręcznik użytkownika pakietu Ragel: http://www.complang.org/ragel/ragel-guide-6.7.pdf.
V1.1 – 6/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Słowa, Języki, Relacje
V1.1 – 7/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Słowa
Podstawowe definicja związane z pojęciem słowa oraz języka: Definicja Alfabet oznaczony przez Σ, to dowolny niepusty, skończony zbiór. Elementy alfabetu nazywamy znakami albo symbolami. Elementy alfabetu to zazwyczaj cyfry i litery, ale mogą to być dowolne inne symbole. Definicja Słowo (lub napis) nad alfabetem Σ, to dowolny skończony ciąg symboli z Σ. Słowem jest też ciąg/słowo puste oznaczone przez λ bądź ε. Definicja Długość słowa oznaczamy przez | · | i jest to liczba symbol słowie. Przykłady: |abc| = 3 oraz |λ| = 0. V1.1 – 8/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Słowa
Definicja Sklejenie (inne określenie to konkatenacja) słów to słowo z powstałe z połączenia z dwóch słów x,y : z = x + y , co oznacza że sklejane słowa są zapisane jedno po drugim. Przykład: jeśli x = Ala, y = Ma, z = Kota, to zyx = KotaMaAla. Sklejanie słów jest łączne: x(yz) = (xy )z, oraz λ jest elementem neutralnym operacji sklejania, tzn. xλ = λx = x. Definicja Wyrażenie an oznacza n-krotne powtórzenie symbolu a. Jeśli x jest słowem, to x n oznacza n-krotne powtórzenie słowa. Dodatkowo x 0 = λ, x n+1 = x n x. Przykłady: a4 = aaaa, a0 = λ, b n+1 = b n a, x 0 = λ, x n+1 = x n x, gdzie a,b to symbole natomiast x jest słowem, oraz jeśli x = kolor , to x 3 = kolorkolorkolor .
V1.1 – 9/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Słowa
Definicja Liczbę wystąpień symbolu a w słowie x oznaczamy przez #a (x). Podsłowem danego słowa x nazywamy dowolny spójny fragment słowa x, tzn. y jest podsłowem x jeśli, gdy istnieją takie v i w , że x = vyw . Definicja Prefiksem słowa nazywamy dowolny jego początkowy fragment, tzn. x jest prefiksem y , gdy istnieje takie z, że xz = y . Dodatkowo, jeśli x 6= λ i x 6= y , to x jest właściwym prefiksem y . Sufiksem słowa x nazywamy dowolny końcowy fragment x, tzn. x jest sufiksem y , gdy istnieje takie z, że zx = y . I podobnie, gdy x 6= λ oraz x 6= y , to x jest właściwym sufiksem y Definicja − Przez rev (x) lub ← x oznaczamy słowo x czytane wspak.
V1.1 – 10/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Język
Definicja Język L, to dowolny zbiór słów nad alfabetem Σ. Język złożony ze wszystkich możliwych słów nad alfabetem łączenie ze słowem pustym, będziemy oznaczać przez Σ? . Podstawowe operacje na językach są następujące: ∅ to pusty język, który nie zawiera żadnego słowa, A ∪ B to suma języków A i B, A ∩ B to część wspólna (przecięcie) języków A i B, A \ B to różnica języków A i B. Przez A oznaczymy dopełnienie języka A, czyli A = Σ? \ A. Natomiast AB oznacza konkatenację języków A i B, czyli jest to język zawierający wszystkie możliwe sklejenia słów z A i słów B, AB = {xy : x ∈ A, y ∈ B}.
V1.1 – 11/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Język
Język An jest określony rekurencyjnie: A0 = {λ}, An+1 = An A. Można powiedzieć, że język An to język zawierający wszystkie możliwe sklejenia n słów wziętych z A, i dodatkowo słowa to niekoniecznie muszą się różnić. Domknięcie Kleene’ego S Domknięcie Kleene’ego języka A, oznaczane jako A? , to A? = n≥0 An . Inaczej mówiąc, A? to język zawierający wszystkie możliwe sklejenia dowolnej liczby słów należących do A, także ze słowem pustym. Natomiast przez A+ oznaczamy język zawierający wszystkie możliwe sklejenia dowolnej dodatniej liczby słów należących do A, czyli A+ = AA? , co oznacza brak słowa pustego.
V1.1 – 12/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Relacje
Niech X reprezentuje dowolnym zbiór, a ρ ∈ X × X relację binarną, która jest określona na tym zbiorze, wtedy: relacja ρ jest zwrotna, gdy dla każdego x ∈ X zachodzi xρx, relacja ρ jest symetryczna, gdy dla dowolnych x, y ∈ X , jeśli xρy , to również y ρx, relacja ρ jest przechodnia, gdy dla dowolnych x, y , z ∈ X , jeżeli xρy ∧ y ρz, to również xρz, relacja ρ jest antysymetryczna, gdy dla dowolnych x, y ∈ X , jeżeli xρy ∧ y ρx, to również x = y . Dwie istotne własności: jeśli ρ jest zwrotna, symetryczna i przechodnia, to ρ jest relacją równoważności, jeśli ρ jest zwrotna, przechodnia i antysymetryczna, to ρ jest relacją częściowego porządku.
V1.1 – 13/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Relacje
Relacja równoważności dzieli zbiór X na rozłączne klasy abstrakcji: Definicja Jeśli ρ jest relacją równoważności, x ∈ X , to przez [x]ρ oznaczono klasę abstrakcji x: [x]ρ = {y ∈ X : xρy } Przez X/ρ oznaczono zbiór klas abstrakcji elementów zbioru X : X/ρ = {[x]ρ : x ∈ X }
V1.1 – 14/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Relacje
(a)
(b)
Relacja zwrotna (a) oraz relacja symetryczna (b).
V1.1 – 15/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Relacje
(a)
(b)
Relacja antysymetryczna (a) oraz relacja przechodnia (b).
V1.1 – 16/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Relacje
Relacja równoważności.
V1.1 – 17/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Relacje
Relacja częściowego porządku.
V1.1 – 18/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Relacje
Domknięcie relacji Niech ρ ⊆ X ×X będzie dowolną relacją binarną. Domknięciem przechodnio0 zwrotnym relacji ρ nazywamy najmniejszą taką relację ρ ⊂ X × X , że: 0
zawiera relację ρ, ρ ⊆ ρ , jest zwrotna i przechodnia.
Domknięcie przechodnio-zwrotne.
V1.1 – 19/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Relacje
Domknięcie relacji
Definicja domknięcia przechodniego relacji ρ oznaczonego przez ρp : jeśli a ρ b to a ρp b, jeśli a ρ b i b ρ c, to a ρp c. 0
Domknięcie przechodnio zwrotne relacji ρ oznaczono jako ρ , to ρp ∪ {xρx | x ∈ X }. Przykład Niech ρ = {(1, 2), (2, 2), (2, 3)} oraz X = {1, 2, 3}, to otrzymuje się: ρp = {(1, 2), (2, 2), (2, 3), (1, 3)}, 0
ρ = {(1, 1)(1, 2), (1, 3), (2, 2), (2, 3), (3, 3)}.
V1.1 – 20/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Zastosowanie automatów
Zastosowanie automatów
Automat skończony jest modelem matematycznym systemu o dyskretnych wejściach i wyjściach. System taki może znajdować się w jednym ze skończonej liczby stanów (dopuszczalne są także systemy, gdzie automat może się znajdować w wielu stanach na raz). Stan systemu stanowi podsumowanie informacji dotyczących poprzednich wejść. Informacja ta jest niezbędna do określenia zachowania systemu przy następnych wejściach. Istnieje wiele przykładów zastosowań automatów. Prostym przykładem jest mechanizm windy. Mechanizm ten nie pamięta wszystkich poprzednich żądań. Pamiętane jest tylko bieżące piętro, kierunek ruchu (w górę lub w dół) oraz zbiór żądań do obsłużenia.
V1.1 – 21/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Zastosowanie automatów
Zastosowanie automatów
Inne przykładowe zastosowania automatów: oprogramowanie do projektowania obwodów cyfrowych oraz testy poprawności obwodu, zastosowanie w kompilatorach jako analizator leksykograficzny, którego zadaniem jest rozbicie tekstu kodu źródłowego na pojedyncze jednostki logiczne takie jak identyfikatory, słowa kluczowe czy znaki przestankowe, skanowanie większych ilości tekstu np.: zbiór stron WWW, celem odnalezienia wystąpień określonych słów czy całych zwrotów, weryfikacja systemów o skończonej liczbie stanów jak min. protokoły komunikacyjne, protokoły bezpieczeństwa związane z wymianą informacji.
V1.1 – 22/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Zastosowanie automatów
Wilk, człowiek, kapusta, rzeka ... start CWKS-#
K
WS-CK
CWS-K
C
W
S
S-CWK
W-CKS
K
K
CKS-W
CWK-S
S
#-CWKS
K
CK-WS
C
W
K-CWS
V1.1 – 23/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Zastosowanie automatów
Odtwarzacz DVD, Bluray, mp3 ... eject start
empty
insert
play
stop
eject
ffwd stop
rev
play eject
rev
play
stop rev
play
ffwd
stop ffwd rev
ffwd
eject V1.1 – 24/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Zastosowanie automatów
Deterministyczny automat skończony – definicja
Deterministyczny automat skończony (w skrócie DAS lub ang. FDA – finite deterministic automata) jest zbudowany z następujących elementów: 1
skończonego zbioru stanów, oznaczonych symbolem Q,
2
skończonego zbioru symboli wejściowych (nazywanego także alfabetem), oznaczonych symbolem Σ,
3
funkcji przejścia, przyjmującej za argument stan oraz symbol wejściowy a jej wynikiem jest stan, funkcja przejścia będzie oznaczana przez symbol δ,
4
stanu początkowego, jest to jeden wyróżniony stan z Q np.: q0 ,
5
zbioru stanów końcowych, gdzie wyróżnia się zbiór stanów akceptujących F , gdzie F ⊂ Q.
V1.1 – 25/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Zastosowanie automatów
DAS – definicja formalna Definicja deterministycznego automatu skończonego Deterministyczny automat skończony A, to krotka albo prościej następująca piątka: A = (Q, Σ, δ, q0 , F ): Q to skończony zbiór stanów, Σ to skończony alfabet wejściowy, δ : Q × Σ → Q, to funkcja przejścia δ(q, a) s to stan początkowy, F ⊆ Q to zbiór stanów akceptujących. Automat i funkcja przejścia określona jako tabela: 0
1
q0
0
q1
1
q2
0, 1
δ → q0 q1 ?q2
0 q1 q1 q2
1 q0 q2 q2 V1.1 – 26/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Zastosowanie automatów
Projektowanie automatu
Określenie języka C , zawierającego podciąg 01: C = {x01y | x, y są dowolnymi łańcuchami zer i jedynek} Przykładami łańcuchów należących do języka C są ciągi: 01, 11010 oraz 100011. Przykładami ciągów nienależących do języka C są ciągi λ (czyli ciąg pusty), 0 oraz 111000. Łatwo stwierdzić iż alfabet to tylko dwa znaki Σ = {0, 1}. Istnieje pewien zbiór stanów Q którego na razie nie precyzujemy, ale już można wyróżnić stan początkowy q0 . Automat musi zostać skonstruowany w taki sposób, aby niejako pamiętał ważne fakty odnośnie tego, co pojawiło się na wejściu. W przypadku postawionego zadania możemy wyróżnić trzy następujące zdarzenia:
V1.1 – 27/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Zastosowanie automatów
Trzy obserwacje
1
Czy na wejściu pojawił się podciąg 01? Jeśli tak, to można zaakceptować dowolny ciąg zer i jedynek, ponieważ ciąg jest zbudowany zgodnie z językiem L. Oznacza to także że następne stany mogą być stanami akceptującymi.
2
Jak dotąd podciąg 01 nie pojawił się jeszcze, ale ostatnim widzianym symbolem było 0, jeśli teraz pojawi się 1, oznaczać to będzie, że pojawił się podciąg 01 i następne symbole mogą być dowolnym ciągiem zer i jedynek.
3
Jak dotąd podciąg 01 nie pojawił się jeszcze, co więcej poprzedni symbol nie został jeszcze podany, bo automat właśnie rozpoczął swoją pracę bądź ostatnim symbolem była jedynka. W takim przypadku automat A nie może zaakceptować słowa, dopóki nie pojawi się zero, a bezpośrednio po zerze jedynka.
V1.1 – 28/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Zastosowanie automatów
Projektowanie automatu
Wymienione warunki należy przedstawić za pomocą stanów. Warunek (3) będzie reprezentowany przez stan q0 . Jest to uzasadnione tym, że jeśli zaczynamy, to musimy wykryć zero, a następnie jedynkę. Jeśli będąc w stanie q0 zobaczymy w pierwszej kolejności jedynkę, to naturalnie nadal musimy pozostać w stanie q0 . Zapiszemy to w następujący sposób δ(q0 , 1) = q0 . Będąc w stanie q0 , gdy napotkamy zero to zaczyna obowiązywać warunek (2), czyli δ(q0 , 0) = q2 . Przybliża nas to do wykrycia, obecności podciągu 01. Pierwsza istotna sytuacja dla stanu q2 , to wykrycie następującego symbolu którym jest zero. Jeśli tak jest to, δ(q2 , 0) = q2 , co oznacza iż naturalnie pozostajemy w stanie q2 . Jednakże jeśli będąc w stanie q2 , wykryjemy zero to wiedząc iż pojawiło się już zero to uzyskaliśmy informację o tym, że wystąpił pod ciąg 01. Przechodzimy do stanu q1 , oznaczający stan akceptujący, δ(q2 , 1) = q1 .
V1.1 – 29/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Zastosowanie automatów
Projektowanie automatu Stan q1 może przyjmować, zero bądź jedynkę w dowolnej kolejności ponieważ już wcześniej udało nam się stwierdzić obecność 01. Funkcja przejścia posiada postać δ(q1 , 0) = q1 oraz δ(q1 , 1) = q1 . Zbierając uzyskane informacje, formalnie automat A zdefiniujemy w następujący sposób: ADAS = {q0 , q1 , q2 }, {0, 1}, δ, q0 , {q1 } A funkcja przejścia jest następująca: → q0 ?q1 q2
0 q2 q1 q2
1 q0 q1 q1
V1.1 – 30/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Funkcja przejścia
Funkcja przejścia Przydatne jest aby funkcję δ określoną na stanie i pojedynczym symbolu, rozszerzyć tak aby określa działanie automatu dla słów. Rozszerzona funkcja przejścia – oznaczona jako δˆ albo δ ? Rozszerzona funkcja przejścia δ ? : Q × Σ? → Q jest zdefiniowana w następujący sposób: δ ? (q, λ) = q, δ ? (q, xa) = δ(δ ? (q, x), a). gdzie a to symbol, natomiast x słowo. Automat akceptuje słowo x ⇔ δ ? (q, x) ∈ F , co pozwala określić język akceptowalny przez automat A. Akceptowany język Język L akceptowany przez automat A, to: L(A) = {x ∈ Σ? : δ ? (q, x) ∈ F }. V1.1 – 31/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Własności automatów
O możliwości budowy automatu Własność Każdy język skończony jest akceptowany przez pewien deterministyczny automat skończony. Szkic dowodu, z użyciem prefiksów. Niech L będzie skończonym językiem. Wszystkie słowa z L mają skończoną liczbę prefiksów. Stanami automatu akceptującego L będą wspomniane prefiksy, oraz jeden dodatkowy stan, który będziemy nazywać „śmietnikiem” i będziet ostan nieakceptujący. Po wczytaniu dowolnego słowa, jeżeli jest ono prefiksem pewnego słowa z L, nasz automat A będzie dokładnie w takim stanie jak to słowo. Natomiast po wczytaniu słowa, które nie jest prefiksem żadnego słowa z A automat przejdzie do śmietnika. Stan początkowy to λ. Jeśli x i xa są prefiksami pewnego słowa z L, to δ(q, a) = xa, w przeciwnym przypadku: δ(q, a) = śmietnik. Stany akceptujące to te prefiksy, które należą do L. W oczywisty sposób, język akceptowany przez automat A to L. Natomiast dzięki temu, że słowa z L mają skończoną liczbę prefiksów, jest to poprawny automat skończony.
Za wykładem: M.Kubicy, Języki formalne i automaty. V1.1 – 32/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Własności automatów
Przykład Dla języka L1 = {ab, aba, abb, baa}, zbiór prefiksów jest następujący: {λ, a, b, ab, ba, aba, abb, baa}
a b
a
a a,b
a aba
ab b
a,b abb
b
λ b
a
b b a,b
ba a baa
→λ a b ? ab ba ? aba ? abb ? baa ∅
a a ∅ ba aba baa ∅ ∅ ∅ ∅
b b ab ∅ abb ∅ ∅ ∅ ∅ ∅
a,b
V1.1 – 33/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Własności automatów
Dopełnienie, produkt i suma automatów Twierdzenie Niech L1 i L2 będą językami (alfabet Σ wspólny dla obu języków) akceptowanymi odpowiednio przez automaty deterministyczne A1 = (Q1 , Σ, δ1 , q1 , F1 ) i A2 = (Q2 , Σ, δ2 , q2 , F2 ), oraz L(A1 ) = L1 , L(A2 ) = L2 . Następujące języki są również akceptowane przez pewne deterministyczne automaty skończone: L1 , L1 ∩ L2 , L1 ∪ L2 . 0
Dowód dla dopełnienia: Niech A1 = (Q1 , Σ, δ1 , q1 , Q \ F1 ), toteż 0
L(A1 )
= = = =
{x ∈ Σ? : δ ? (q1 , x) ∈ Q \ F1 } {x ∈ Σ? : δ ? (q1 , x) ∈ / F1 } Σ? \ {x ∈ Σ? : δ ? (q1 , x) ∈ / F1 } Σ? \ L(L1 ) = Σ? \ L1 = L1 . V1.1 – 34/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Własności automatów
Dopełnienie, produkt i suma automatów Dowód dla produktu automatów: Niech A3 = (Q1 × Q2 , Σ, δ3 , (q1 , q2 ), F1 × F2 ), co pociąga za sobą konieczność iż zachodzi δ3 ((q1 , q2 ), a) = (δ3 (q1 , a), δ3 (q2 , a)), gdzie a to symbol. Wykorzystując indukcję po długości słowa x, należy wykazać że zachodzi δ3? ((p, q), x) = (δ3? (p, x), δ3? (q, x)), gdzie x to słowo. Co pozwala uzyskać że L(A3 )
= = = = =
{x ∈ Σ? : δ3? ((q1 , q2 ), x) ∈ F1 × F2 } {x ∈ Σ? : (δ1? (q1 , x), δ2? (q2 , x)) ∈ F1 × F2 } {x ∈ Σ? : δ1? (q1 , x) ∈ F1 ∧ δ2? (q2 , x) ∈ F2 } {x ∈ Σ? : δ1? (q1 , x) ∈ F1 } ∩ {x ∈ Σ? : δ2? (q2 , x) ∈ F2 } L(A1 ) ∩ L(A2 ) = L1 ∩ L2
Dowód dla sumy automatów, sprowadza się do wykorzystania praw de Morgana: L1 ∪ L2 = L1 ∩ L2 V1.1 – 35/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Własności automatów
Przykład Produkt automatów akceptujących parzystą liczbę symboli b oraz parzystę liczbę symboli a: a
b
p
b
a
pr
q
b a
→?p q
a p q
b q p
b
a
b
r
a
s
→r ?s
a s r
b r s
qr
b
a
a
a
b ps
→ pr qr ? ps qs
a ps qs pr qr
b
qs
b qr pr qs ps V1.1 – 36/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Minimalizacja automatów
Minimalizacja automatów
Dlaczego warto minimalizować automaty, podczas projektowania automatu dla konkretnego rozwiązania można otrzymać kilka projektów. Najczęściej wybiera się projekt najmniejszy, który działa na najmniejszej możliwej liczbie stanów. Działanie „na oko”, celem wyboru najmniejszego automatu, jest raczej możliwe tylko dla małych przypadków. Minimalizacja automatu pozwala też na łatwą ocenę jaki język jest akceptowany przez automat. Ważny fakt Do każdego deterministycznego automatu skończonego zawsze istnieje jednoznaczny automat minimalny, który akceptuje ten sam język.
V1.1 – 37/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Minimalizacja automatów
Minimalizacja automatów – „przykład na oko”
Minimalizacja następującego automatu deterministycznego? a
p a,b
a s b
r a
b
a,b t
b
q
Jaki język akceptuje ten automat?
V1.1 – 38/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Minimalizacja automatów
Minimalizacja automatów – „przykład na oko”
Usunięcie stanów nieosiągalnych, daje następujący automat: a a s b
r a
b
a,b t
b
q
V1.1 – 39/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Minimalizacja automatów
Minimalizacja automatów – „przykład na oko” i wnioski Analiza stanów q oraz r pozwala je połączyć w jeden stan: a,b s
a
b
a,b
r
t
W algorytm minimalizacji można wyróżnić dwie fazy: 1 usunięcia stanów nieosiągalnych, 2
wyznaczenia relacji równoważności ≈ i połączenia ze sobą stanów równoważnych.
Definicja Dwa stany p i q są sobie równoważne, gdy: ∀x∈Σ? δ ? (p, x) ∈ F ⇔ δ ? (q, x) ∈ F . V1.1 – 40/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Minimalizacja automatów
Algorytm minimalizacji znajduje wszystkie pary nierównoważnych sobie stanów. Co oznacza, że pozostałe pary stanów są sobie równoważne i można je ze sobą połączyć. Definicja Jeśli stany p i q nie są sobie równoważne, to istnieje rozróżniające je słowo x, takie iż: δ ? (p, x) ∈ F < δ ? (q, x) ∈ F . Ogólna zasada polega na tym, iż zakłada się, że wszystkie stany można skleić ze sobą. Następnie sukcesywnie wyznaczane są pary stanów nie równoważnych, w kolejności uwzględniającej rosnącą długości najkrótszych rozróżniających je słów.
V1.1 – 41/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Minimalizacja automatów
Algorytm minimalizacji automatu
Poszczególne kroki algorytmu minimalizacji: (I) tworzona jest tablica wartości logicznych Tp,q indeksowaną nieuporządkowanymi parami {p, q} stanów p, q ∈ Q. Na początku zakłada się, że Tp,q = true dla wszystkich p, q ∈ Q, (II) dla wszystkich par stanów {p, q}, takich że p ∈ F i q ∈ / F zaznaczamy Tp,q = false (jeśli p jest akceptujący, a q nie jest, to te stany są rozróżniane przez słowo puste λ), (III) dla wszystkich par stanów {p, q} oraz znaków a ∈ Σ takich, że Tδ(p,a),δ(q,a) = false, zaznaczamy również T p, q = false. (IV) jeśli w kroku (III) zmieniona została choćby jedną wartość tablicy T z true na false, to krok (III) należy powtarzać tak długo, aż nie będzie on powodował żadnych nowym zmian w tablicy T .
V1.1 – 42/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Minimalizacja automatów
Minimalizacja – przykład Minimalizacja następującego automatu: s
p
a b b
a
b
a
b r
a
p F q T F r F T F s
q
Wartości z tabeli T wskazują że należy połączyć stany s i q oraz p oraz r , co pozwala na podanie poniższego automatu: s,q
a,b
p,r
a,b
V1.1 – 43/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Minimalizacja automatów
Minimalizacja – przykład Minimalizacja następującego automatu: 0 q1
0
q2
1 q3
1 0
1
1
q4 1
0 q5
0
0 1
q6
0 1
q7
1 q8
q2 q3 q4 q5 q6 q7 q8
F F F T F F F q1
F F F F F T q2
F F F F F q3
F T F F q4
F F F F F F q5 q6 q7
0
q1 , q5
Wartości z tabeli T wskazują że należy połączyć stany q1 i q5 , q2 i q8 oraz q4 i q6 , co pozwala na podanie poniższego automatu:
0
0
1
1 q2 , q8 0
1 0
q7 1
q3 1
0
q4 , q6 V1.1 – 44/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Automaty i pakiet Ragel State Machine Compiler
V1.1 – 45/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Możliwości pakietu Ragel
Czas na trochę praktyki: Ragel State Machine Compiler Ragel to pakiet do kompilacji tzw. maszyn stanu, czyli również automatów. Pakiet jest dostępny pod adresem: http://www.complang.org/ragel/. Współpracuje z wieloma językami programowania: C, C++, Objective-C, D, Java, Ruby, co ważne nie są wymagane żadne dodatkowe pakiety. Zastosowania to min.: implementacja protokołów, analiza danych, analiza leksykalna języków programowania, weryfikacja danych wprowadzanych przez użytkownika. Maszyna stanu jest opisana przez: operatory języka regularnego, diagramy przejścia, skanery, oraz metody łączące powyższe podejścia. V1.1 – 46/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Przykłady zastosowań
Automat dla języka L = (a|b)? bb Implementacja funkcji do rozpoznawania języka L = (a|b)? bb, w notacji Ragel zapiszemy to jako [ab]*[b][b]. Początek: #include
#include %%{ machine lang; main := ( [ab]*[b][b] ) 0 @{ val = 1; }; }%% %% write data; Wyrażenia objęte ciągiem %%{ oraz }%% są przetwarzane przez pakiet Ragel. V1.1 – 47/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Przykłady zastosowań
Automat dla języka L = (a|b)? bb Postać funkcji main: int main( int argc, char **argv ) { int cs, val = 0; if ( argc > 1 ) { char *p = argv[1]; char *pe = p + strlen(p) + 1; %% write init; %% write exec; } printf("result = %i\n", val ); return 0; } V1.1 – 48/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Przykłady zastosowań
Funkcja typu atoi Implementacja funkcji atoi, czyli funkcji która zamienia liczbę zapisaną jako tekst na wartość np.: int (w przykładzie będzie to long long). Początek: #include #include #include %%{ machine atoi; write data; }%% Wyrażenia objęte za %%{ oraz }%% są przetwarzane przez pakiet Ragel. Przykład pochodzi ze strony projektu Ragel. V1.1 – 49/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Przykłady zastosowań
Funkcja atoi long long atoi( char *str ) { char *p = str, *pe = str + strlen( str ); int cs; long long val = 0; bool neg = false; %%{ action see_neg { neg = true; } action add_digit { val = val * 10 + (fc - ’0’); } Przykład pochodzi ze strony projektu Ragel. V1.1 – 50/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Przykłady zastosowań
Funkcja atoi main := ( ’-’@see_neg | ’+’ )? ( digit @add_digit )+ ’\n’; write init; write exec; }%% if ( neg ) val = -1 * val; if ( cs < atoi_first_final ) fprintf( stderr, "atoi: there was an error\n" ); return val; };
Przykład pochodzi ze strony projektu Ragel. V1.1 – 51/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Przykłady zastosowań
Funkcja atoi – funkcja main
#define BUFSIZE 1024 int main() { char buf[BUFSIZE]; while ( fgets( buf, sizeof(buf), stdin ) != 0 ) { long long value = atoi( buf ); printf( "%lld\n", value ); } return 0; } Przykład pochodzi ze strony projektu Ragel.
V1.1 – 52/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Przykłady zastosowań
Obsługa parametrów z linii komend Analiza parametrów przekazanych przez linię poleceń: ./prog -M 0 --output /dev/xVideo0. Definicja poszczególnych parametrów obsługiwanych w programie: string = [^\0]+ >clear $append %term; help = ( ’-h’ | ’-H’ | ’-?’ | ’--help’ ) 0 @help; version = ( ’-v’ | ’--version’ ) 0 @version; output = ’-o’ 0? string 0 @output; spec = ’-S’ 0? string 0 @spec; mach = ’-M’ 0? string 0 @mach; main := ( help | version | output | spec | mach )*;
Przykład pochodzi ze strony projektu Ragel.
V1.1 – 53/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
Przykłady zastosowań
Obsługa parametrów z linii komend Podjęcie akcji po wykryciu polecenia: action action action action action action
clear { fsm->buflen = 0; } help { printf("help\n"); } version { printf("version\n"); } output { printf("output: \"%s\"\n", fsm->buffer); } spec { printf("spec: \"%s\"\n", fsm->buffer); } mach { printf("machine: \"%s\"\n", fsm->buffer); }
Postać funkcji main: int main( int argc, char **argv ) { int a; struct params params; params_init( ¶ms ); for ( a = 1; a < argc; a++ ) params_execute( ¶ms, argv[a], strlen(argv[a])+1 ); if ( params_finish( ¶ms ) != 1 ) fprintf( stderr, "params: error processing arguments\n" ); return 0; }
Przykład pochodzi ze strony projektu Ragel. V1.1 – 54/ 55
Wprowadzenie
Słowa, języki, relacje
Automaty
Ragel
A za tydzień na wykładzie
W następnym tygodniu między innymi
1
Automaty niedeterministyczne
2
Automaty z przejściami ε
3
Automat potęgowy (konwersja automatu niedeterministycznego na deterministyczny)
4
Języki regularne
5
Regexy w praktyce
6
Więcej przykładów dla Ragel
Dziękuje za uwagę!!!
V1.1 – 55/ 55
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Automaty (nie)deterministyczne – część II Osoba prowadząca wykład i ćwiczenia: dr inż. Marek Sawerwain Instytut Sterowania i Systemów Informatycznych Uniwersytet Zielonogórski e-mail : [email protected] tel. (praca) : 68 328 2321, pok. 328a A-2, ul. prof. Z.Szafrana 2, 65-246 Zielona Góra
Ostatnia zmiana: 11.12.2012
V1.1 – 1/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Spis treści
1
Wprowadzenie Plan wykładu
2
Automaty niedeterministyczne Automat niedeterministyczny Konwersja NAS na DAS Automat potęgowy Automat z przejściami ε
3
Języki regularne Wzorce Język wzorców Języki regularne
4
A za tydzień na wykładzie
V1.1 – 2/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Plan wykładu
Plan wykładu – spotkania tydzień po tygodniu
(1) Informacje o wykładzie, poprawność algorytmów (2) Poprawność algorytmów – logika Hoarego (3) Analiza złożoności kodu wysokiego i niskiego poziomu (4) Modele algorytmiczne – maszyny proste, obwody logiczne (5) Modele algorytmiczne – maszyna Turinga oraz rachunek-λ (6) Automaty (nie)deterministyczne – część I (7) ⇒ Automaty (nie)deterministyczne – część II ⇐ (8) Gramatyki – regularne i bezkontekstowe
V1.1 – 3/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Plan wykładu
Plan wykładu – spotkania tydzień po tygodniu
(9) Gramatyki i automaty ze stosem (10) Algorytmy równoległe (11) Klasy złożoności obliczeniowej (12) Pamięć logarytmiczna i wielomianowa (13) Problemy NP-zupełne (14) Wstęp do obliczeń kwantowych (15) Wybrane algorytmy kwantowe
V1.1 – 4/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Plan wykładu
Plan wykładu
1
Automaty niedeterministyczne 1 2 3 4
2
definicja A.N. własności A.N. automat potęgowy automat z przejściami ε
języki regularne 1 2 3 4
wzorce i wyrażenia regularne równoważność wzorców i wyrażeń przykłady wyrażeń przykłady dla Flexa
V1.1 – 5/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Plan wykładu
Materiały wykorzystane podczas tworzenia tego wykładu, a także przydatne do dalszych studiów: 1 John E.Hopcroft, Jeffrey D.Ullman: Wprowadzenie do teorii automatów, języków i obliczeń, Wydawnictwo Naukowe PWN 2003 Wydanie 1 oraz Wydanie 2 z roku 2006, 2
przedmiot Języki automaty i obliczenia z Ważniaka,
3
wykład M.Kubicy, Języki formalne i automaty, http://www.mimuw.edu.pl/~kubica/aug/index-frames.html,
4
Podręcznik użytkownika pakietu Ragel: http://www.complang.org/ragel/ragel-guide-6.7.pdf.
V1.1 – 6/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Automaty niedeterministyczne
V1.1 – 7/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Automat niedeterministyczny
Kilka uwag o automacie niedeterministycznym Wprowadzony automat deterministyczny (DAS) jest modelem obliczeń o bardzo prostym opisie działania. Stan procesu zmienia się w sposób jednoznaczny pod wpływem sygnału zewnętrznego reprezentowanego przez jeden symbol z alfabetu Σ. Opisem tych zmian jest reprezentowany przez funkcję δ, nazwaną funkcją przejścia. Jednakże uogólnieniem powyższej sytuacji może być dopuszczenie do sytuacji gdzie funkcja przejścia wskazuje zbiór stanów zamiast tylko jednego symbolu. W efekcie z względu na taki opis zmiany stanów, automat staje się niedeterministyczny (NAS), gdyż z danego stanu automat przechodzi we wskazany zbiór stanów. Jednak z punktu widzenia rozpoznawania języka lub poprawnych obliczeń, takie uogólnienie nie zmienia klasy języków rozpoznawanych przez automaty niedeterministyczne, może jednak powodować iż potrzeba mniej stanów, aby rozpoznać dany języka. Istnieje też zawsze możliwość zamiany automatu niedeterministycznego na automat deterministyczny.
V1.1 – 8/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Automat niedeterministyczny
Automat niedeterministyczny – przykład Automat niedeterministyczny akceptujący słowa zbudowane z zer oraz jedynek, kończące się zerem i jedynką. 0 1 0,1 → q0 {q0 , q1 } {q0 } 0 q1 ∅ {q2 } 1 q0 q1 ?q2 ∅ ∅ Stany jakie przyjmuje automat, dla słowa 00101.
q0
q0
q0
q1
q1
brak ruchu
q0
q0
q0
q1
q2 0
0
q1
1
brak ruchu
q2 0
1
V1.1 – 9/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Automat niedeterministyczny
Definicja automatu deterministycznego – jeszcze raz
Formalna definicja automatu deterministycznego: Definicja deterministycznego automatu skończonego Deterministyczny automat skończony A, to krotka albo prościej następująca piątka: A = (Q, Σ, δ, q0 , F ): Q to skończony zbiór stanów, Σ to skończony alfabet wejściowy, δ : Q × Σ → Q, to funkcja przejścia δ(q, a) q0 to stan początkowy, F ⊆ Q to zbiór stanów akceptujących.
V1.1 – 10/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Automat niedeterministyczny
Definicja automatu niedeterministycznego
Formalna definicja automatu niedeterministycznego: Definicja deterministycznego automatu skończonego Niedeterministyczny automat skończony A, to krotka albo prościej następująca piątka: A = (Q, Σ, δ, {q0 }, F ): Q to skończony zbiór stanów, Σ to skończony alfabet wejściowy, δ : Q × Σ → 2Q , to funkcja przejścia δ(q, a) {q0 } to zbiór stanów początkowych, F ⊆ Q to zbiór stanów akceptujących.
V1.1 – 11/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Automat niedeterministyczny
Własności A.N. Rozszerzona funkcja przejścia δ ? : 2Q × Σ? → 2Q jest określona w następujący sposób: δ ? (q, λ) = q [ δ ? (q, ax) = δ ? δ(q, a), x q∈Q
Niedeterministyczny automat skończony A = (Q, Σ, δ, {q0 }, F ) akceptuje słowo x ⇔ δ ? (q0 , x) ∩ F 6= ∅ . Język akceptowany przez automat A, to: L(A) = {x ∈ Σ? : δ ? (q0 , x) ∩ F 6= ∅} Z formalnego punktu widzenia automaty niedeterministyczne są innym tworem niż automaty deterministyczne. Jednak wolno traktować automaty deterministyczne jak szczególny przypadek automatów niedeterministycznych. V1.1 – 12/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Automat niedeterministyczny
Własności A.N. Ważna własność pokazująca równoważność automatu deterministycznego oraz niedeterministycznego: Niech A = (Q, Σ, δ, {q0 }, F ) będzie automatem deterministycznym. Wówczas automat niedeterministyczny A0 = (Q, Σ, δ 0 , {q0 }, F ), gdzie δ 0 (q, a) = {δ(q, a)} akceptuje dokładnie ten sam język, L(A) = L(A0 ). Dwie przydatne własności: Dla dowolnych x, y ∈ Σ? mamy δ ? (Q, xy ) = δ ? (δ ? (Q, x), y ). a także ? Funkcja rozłączna ze względu na sumowanie zbiorów, tzn.: S δ jest S ? δ ( i Qi , x) = i δ ? (Qi , x).
V1.1 – 13/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Konwersja NAS na DAS
Automaty (nie)deterministyczne przykłady konwersji b q0
a
q01
a,b q0
a
q1
a,b
a q1
b
b
q02
→ q0 q1 ?q2
a {q0 , q1 } {q2 } ∅
b {q0 } {q2 } ∅
→ q0 q01 ?q02 ?q012
a
b
a {q01 } {q012 } {q01 } {q012 }
q012
a
b {q0 } {q02 } {q0 } {q02 }
V1.1 – 14/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Konwersja NAS na DAS
Automaty (nie)deterministyczne przykłady konwersji
p
pr
a
r
a qs
qt
a
a
a
a a
a
q
t
a
s ps
pt a
→ ?p q → ?r s t
a q p s t r
qr
→ ?{p, r } {q, s} ?{p, t} ?{q, r } ?{p, s} {q, t}
a
a {q, s} {p, t} {q, r } {p, s} {q, t} {p, r } V1.1 – 15/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Konwersja NAS na DAS
Automaty (nie)deterministyczne przykłady konwersji 1
0,1 q0
0
q1
1
q0
0 0
q01
q1
1
q02
0 1
∅ → q0 q1 ?q2 {q0 , q1 } ?{q0 , q2 } ?{q1 , q2 } ?{q0 , q1 , q2 }
0 ∅ {q0 , q1 } ∅ ∅ {q0 , q1 } {q0 , q1 } ∅ {q0 , q1 }
1 ∅ {q0 } {q2 } ∅ {q0 , q2 } {q0 } {q2 } {q0 , q2 }
A →B C ?D E ?F ?G ?H
0 A E A A E E A E
1 A B D A F B D F
V1.1 – 16/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Automat potęgowy
Konwersja automatu niedeterministycznego na deterministyczny
Istnieje niedeterministyczny automat A = (Q, Σ, δ, {q0 }, F ) będący automatem skończonym. Odpowiadający mu automat deterministyczny to A0 = (2Q , Σ, δ 0 , {q0 }0 , F 0 ), gdzie: δ 0 (q, a) = δ ? (q, a) oraz F 0 = {q ⊆ Q : A ∩ F 6= ∅} Należy pokazać że obdywa automaty akceptują ten sam język, warto wykorzystać poniższy lemat: Lemat o słowie Dla dowolnych q ⊆ Q oraz x ∈ Σ? zachodzi: δ ? (q, a) = δ ? 0 (q, a) Szkic dowodu lematu: dowód przebiega indukcyjnie ze względu na długość słowa x. Dla słowa pustego mamy: δ ? (q, λ) = δ ? 0 (q, λ) V1.1 – 17/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Automat potęgowy
Konwersja automatu niedeterministycznego na deterministyczny
Zakładając że dla słowa x prawdziwy jest lemat o słowie to będzie on także prawdziwy dla słowa ax: δ ? (q, ax) = δ ? (δ ? (q, a), x) = δ ? (δ 0 (q, a), x) = δ ? (δ ? 0 (q, a), x) Z założenia indukcyjnego wiadomo: δ ? (δ ? 0 (q, a), x) = δ ? 0 (δ ? 0 (q, a), x) = δ ? 0 (q, ax) co kończy dowód lematu. Pokazanie równoważności języków jest następujące: L(A)
= {x ∈ Σ? : δ ? (q, x) ∩ F 6= ∅} = = {x ∈ Σ? : δ ? 0 (q, x) ∩ F 6= ∅} = = {x ∈ Σ? : δ ? 0 (q, x) ∈ F 0 } = L(A0 )
Jeśli w nowo powstałym automacie pojawiają się stany nieosiągalne to można je usunąć bez konsekwencji dla akceptowanego języka. V1.1 – 18/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Automat potęgowy
Konwersja jeszcze jeden przykład - NAS w DAS Automat niedeterministyczny, gdzie ostatnim znakiem w słowie może być zero bądź jeden, ale dwa przedostatnie znaki to zawsze jedynki. 0,1 s
1
t
1
u
0,1
v
Tabela funkcji przejścia jest następująca:
→ ?s t u v
0 {s} ∅ {v } ∅
1 {s, t} {u} {v } ∅
V1.1 – 19/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Automat potęgowy
Konwersja jeszcze jeden przykład - NAS w DAS Automat deterministyczny, gdzie ostatnim znakiem w słowie może być zero bądź jeden, ale dwa przedostatnie znaki to zawsze jedynki. sv 0 1
0
0
0 s
1
st
1
stu
1
stuv
0
Tabela funkcji przejścia jest następująca: → ?s st stu ?sv ?stuv
0 s s sv s sv
1 st stu stuv st stuv V1.1 – 20/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Automat z przejściami ε
Automaty niedeterministyczne z przejściami ε
V1.1 – 21/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Automat z przejściami ε
Przykłady automatów z przejściami ε Automat (a) z przejściami ε oraz równoważne dwa automaty (b) oraz (c). a q0
b ε
ε
q1
c
a
q2
q0
(a)
b b
q1
(b) a
b a
q0
q1
c
q2
c
c b
c
q2
(c) a
(a)
a
b
c
ε
(b)
a
b
c
→1 2 ?3
1 ∅ ∅
∅ 2 ∅
∅ ∅ 3
2 3 ∅
1 ∅ ∅
2 2 ∅
3 3 3
a
→ ?1 ?2 ?3 b
{1, 2, 3} ∅ ∅
∅ {2, 3} ∅
∅ ∅ {3}
(c) →1 →2 → ?3
c
V1.1 – 22/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Automat z przejściami ε
Definicja formalna
Formalna definicja automatu niedeterministycznego z przejściami ε: Definicja deterministycznego automatu skończonego Niedeterministyczny automat skończony A, to krotka albo prościej następująca piątka: A = (Q, Σ, δ, {q0 }, F ): Q to skończony zbiór stanów, Σ to skończony alfabet wejściowy, δ : Q × (Σ ∪ {ε}) → 2Q , to funkcja przejścia δ(q, a) {q0 } to zbiór stanów początkowych, F ⊆ Q to zbiór stanów akceptujących.
V1.1 – 23/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Automat z przejściami ε
Definicja ε-domknięcia
Pojęcie ε-domknięcia, w sposób nieformalny można określić w następujący sposób: ε-domknięcie stanu q to stany które są osiągane tylko i wyłącznie po wszystkich przejściach ze stanu q opatrzonych etykietą ε. Inne stany osiągnięte ze stanu q także podlegają tej procedurze, należy przejść po wszystkich ε-przejściach. Definicja ε-domknięcie ED(q) Podstawa: Stan q należy do ED(q). Krok indukcyjny: Jeśli stan p należy do ED(q) oraz istnieje przejście ze stanu p do stanu r o etykiecie ε, to r też należy do ED(q). Co więcej, dla funkcji przejścia δ i stanu p ∈ ED(q) to ED(q) zawiera także wszystkie stany z δ(p, ε).
V1.1 – 24/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Automat z przejściami ε
Definicja ε-domknięcia
Dla automatu przedstawionego na poniższym rysunku cyfra
cyfra
e,+,-
start q0
cyfra
. q2
q1
cyfra
e q3
q5
.
q4
każdy stan jest własnym ε-domknięciem oraz dla dwóch stanów mamy: ED(q0 ) = {q0 , q1 } oraz ED(q3 ) = {q3 , q5 }
V1.1 – 25/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Automat z przejściami ε
Rozszerzona funkcja przejścia Rozszerzona funkcja przejścia δ ? : 2Q × Σ? → 2Q jest określona w następujący sposób: δ ? (q, ε) = ED(q) [ δ ? (Q, ax) = δ ? δ(q, a), x q∈ED(Q)
Niedeterministyczny automat skończony A = (Q, Σ, δ, {q0 }, F ) akceptuje słowo x ⇔ δ ? (q0 , x) ∩ F 6= ∅ . Język akceptowany przez automat A, to: L(A) = {x ∈ Σ? : δ ? (q0 , x) ∩ F 6= ∅} Każde obliczenie automatu z ε-przejściami to przeplot przejść typu ε oraz zwykłych przejść. Znajduje to wyraz w definicji funkcji δ ? gdzie stosuje się funkcje ED i δ. V1.1 – 26/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Automat z przejściami ε
Usuwanie przejść ε Można pokazać że automaty z ε-przejściami i automaty niedeterministyczne mają taką samą siłę wyrazu. Co implikuje, że automaty z ε-przejściami mają taką samą siłę wyrazu co automaty deterministyczne. Można to pokazać, że można usunąć ε-przejścia bez zmiany akceptowanego języka. Niech A = (Q, Σ, δ, {q0 }, F ) będzie automatem skończonym z ε-przejściami. Równoważny mu niedeterministyczny automat skończony A0 ma postać A0 = (Q, Σ, δ 0 , {q0 }0 , F ), gdzie S 0 = ED(S), δ 0 (q, a) = ED(δ(q, a)) (dla a 6= ε). Szkic dowodu: Wiadomo że zbiory stanów i stanów akceptujących są w obu automatach takie same. Należy pokazać ze względu na indukcję po długości słowa x, że dla dowolnego q ∈ Q zachodzi: δ ? (q, a) = δ ? 0 (ED(q), x). Dla x = ε otrzymuje się: δ ? (q, ε) |= ED(q) = δ ? 0 (ED(q), ε) V1.1 – 27/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Automat z przejściami ε
Usuwanie przejść ε
Zakładając, że teza jest prawdziwa dla x. Należy pokazać jej prawdziwość dla ax (dla dowolnego a ∈ Σ): S δ ? (q, ax) = δ ? q∈ED(A) δ(q, a), x = S = δ ? 0 ED( q∈ED(A) δ(q, a)), x = S = δ? 0 q∈ED(A) ED(δ(q, a)), x = S 0 = δ? 0 δ (q, a), x = δ ? 0 (ED(q), ax) q∈ED(A) Co pozwala na określenie postaci akceptowanych języków: L(A0 ) = {x ∈ Σ? : δ ? 0 (S 0 , x)∩F 6= ∅} = {x ∈ Σ? : δ ? (ED(S), x)∩F 6= ∅} = L(A)
V1.1 – 28/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Języki regularne
V1.1 – 29/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Wzorce
Nim przejdziemy dalej – wzorce Wyrażenia stosowane we wzorcach: dla a ∈ Σ, symbol a jest wzorcem, do którego pasuje tylko symbol a, λ jest wzorcem, do którego pasuje tylko słowo puste, ∅ jest wzorcem, do którego nie pasuje żadne słowo, . to wzorzec, do którego pasuje dowolny znak (oprócz końca wiersza), "x"to wzorzec, do którego pasuje tylko słowo x, \a — ma analogiczne znaczenie jak w języku C, np. \n oznacza znak nowej linii, [...] to wzorzec, do którego pasuje dowolny ze znaków umieszczoncyh w kwadratowych nawiasach, np. do wzorca [abc] pasuje dowolny ze znaków a, b bądź c, [a - d] to wzorzec, do którego pasuje dowolny znak od a do d, zakresy takie można łączyć, np. [a - z][A - Z] to wzorzec, do którego pasuje dowolna litera, mała bądź duża, V1.1 – 30/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Wzorce
Nim przejdziemy dalej – wzorce Wyrażenia stosowane we wzorcach: [^...] to wzorzec, do którego pasuje dowolny znak oprócz znaków wymienionych wewnątrz kwadratowych nawiasów, np. do [^xyz] pasuje dowolny znak oprócz x, y i z, jeśli α jest wzorcem, to α? jest wzorcem, do którego pasuje λ oraz wszystkie te słowa, które pasują do α, jeśli α jest wzorcem, to α* jest wzorcem, do którego pasuje sklejenie zera lub więcej słów pasujących do α, jeśli α jest wzorcem, to α+ jest wzorcem, do którego pasuje sklejenie jednego lub więcej słów pasujących do α, jeśli α i β są wzorcami, to αβ jest wzorcem, do którego pasują sklejenia słów pasujących do α i słów pasujących do β, jeśli α i β są wzorcami, to α|β jest wzorcem, do którego pasują te słowa, które pasują do α lub do β, V1.1 – 31/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Wzorce
Nim przejdziemy do dalej – wzorce
Wyrażenia stosowane we wzorcach: jeśli α i β są wzorcami, to α ∩ β jest wzorcem, do którego pasują te słowa, które równocześnie pasują do α i β, jeśli α jest wzorcem, to α jest wzorcem, do którego pasują wszystkie te słowa, które nie pasują do α, jeśli α jest wzorcem, to jest nim również (α) i pasują do niego te same słowa, co do α, ta reguła pozwala stosować nawiasy we wzorcach. Przykłady [0 - 9]+ – ciągi cyfr, czyli liczb naturalne, ?
słowo abba pasuje do wzorca: (a? bba? ) ∩ (ab|ba) .
V1.1 – 32/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Język wzorców
Język wzorców Niech L(α) oznacza język opisany przez wzorzec α i podobnie L(β), to można określić następujący przypadki: L(a) = {a}, L(λ) = {λ}, L(∅) = ∅ L(.) = Σ \ {\n}, L(”x”) = {x}, L([a1 a2 a3 . . . ak ]) = {a1 , a2 , a3 , . . . , ak } L([a − d ]) = {a, b, . . . , d }, L(ˆ[a − d ]) = Σ \ {a, b, . . . , d } L(α?) = L(α) ∪ {λ}, L(α? ) = L(α)? , L(α+ ) = L(α)+ = L(α)L(α)? , L(αβ) = L(α)L(β) L(α|β) = L(α) ∪ L(β) L(α ∩ β) = L(α) ∩ L(β) L(α) = L(α), L((α)) = L(α) V1.1 – 33/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Język wzorców
Język wzorców – równoważność
Dwa wzorce α oraz β są równoważne α ≡ β, wtedy i tylko wtedy, gdy L(α) = L(β). Przykładowe tożsamości dla wzorców: α(β|γ) ≡ αβ|αγ – rozdzielność konkatenacji względem sumowania, (β|γ)α ≡ βα|γα – rozdzielność konkatenacji względem sumowania, ∅α ≡ α∅ ≡ ∅ – ∅ pełni rolę zera w języku wzorców, α? ≡ λ|αα? ≡ λ|α? α, α+ ≡ α|αα+ ≡ α|α+ α, (αβ)? α ≡ α(βα)? , (α? )? ≡ α? , (α|β)? ≡ (α? β ? )?
V1.1 – 34/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Język wzorców
Wyrażenia regularne
Zapis wzorców jest możliwy przy pomocy ograniczonego do niezbędnego minimum zbioru operatorów, toteż Wyrażenia regularne, to wzorce, które są zbudowane tylko przy użyciu następujących reguł: λ, ∅, a, dla a ∈ Σ, αβ, gdzie α oraz β to wyrażenia regularne, α|β, gdzie α oraz β to wyrażenia regularne, α? , gdzie α to wyrażenie regularne, (α), gdzie α to wyrażenie regularne.
V1.1 – 35/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Języki regularne
Języki regularne Wzorce generujące słowa, tworzą klasę języków nazywanymi językami regularnymi. Języka L jest regularny, wtedy i tylko wtedy, gdy istnieje wzorzec α opisujący opisujący L, co oznacza L = L(α). Dwa ważne fakty: Fakt 1 Każdy język skończony jest regularny. Fakt 2 Niech A i B są językami regularnymi. Języki A ∪ B, A ∩ B, AB, A, A? są także regularne.
V1.1 – 36/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Języki regularne
Języki regularne
Dowód faktu 1: Niech {x1 , x2 , ..., xn } będzie niepustym skończonym językiem. Język ten można opisać wzorcem (a dokładniej wyrażeniem regularnym) postaci x1 |x2 |...|xn . Język pusty można opisać wzorcem ∅. Dowód faktu 2: Skoro A i B są regularne, to istnieją opisujące je wzorce α i β, L(α) = A, L(β) = B. Interesujące nas języki są regularne, bo opisują je wzorce: α|β, α ∩ β, αβ, a i α? .
V1.1 – 37/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Języki regularne
Lemat o pompowaniu dla języków regularnych Nie każdy język musi być językiem regularnych, przykładem jest L = {an b n : n ≥ 0}, bowiem nie ma możliwości aby za pomocą stałej ilości pamięci można było sprawdzić, czy dane słowo należy do języka L. Aby zbudować odpowiedni dowód, należy dowodzić nie wprost, że L nie jest regularne. Toteż zakłada się iż L jest regularne. Niech A = (Q, Σ, δ, q0 , F ) będzie automatem akceptującym L i niech n = |Q|. Wówczas z zasady szufladkowej Dirichleta wiadomo iż istnieje taki stan q, u ≥ 0 oraz v > 0, że n = u + v , δ ? (q0 , au ) = δ ? (q, av ) = q. Wówczas tak samo jest akceptowane słowo au b n i an b n (lub nie jest akceptowane). Oznacza to sprzeczność, więc założenie, iż L jest regularny było fałszywe. Lemat o pompowaniu dla języków regularnych Niech L będzie językiem regularnym. Wówczas istnieje takie k, że dla dowolnych słów x, y i z takich, że xyz ∈ L oraz |y | ≥ k, można y podzielić na słowa u, v i w , y = uvw w taki sposób, że v 6= ε i dla wszystkich i ≥ 0, xuv i wz ∈ L. V1.1 – 38/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Języki regularne
Lemat o pompowaniu dla języków regularnych Szkic dowodu:
Jeśli L jest językiem regularnym, to istnieje automat deterministyczny A = (Q, Σ, δ, q0 , F ) rozpoznający ten język i k = |Q|. Niech x, y oraz z będą takimi słowami, że xyz ∈ L oraz |y | ≥ k. W automacie A podczas obliczeń związanych z akceptacją xyz, w trakcie wczytywania słowa y , pojawia się przynajmniej k + 1 stanów. Zasada szufladkowa Dirichleta sugeruje, że przynajmniej jeden z tych stanów musi się powtarzać. Biorąc pierwsze powtórzenie się stanu w trakcie wczytywania słowa y, słowa y można podzielić na trzy części y = uvw : u - od początku słowa y do pierwszego wystąpienia powtarzającego się stanu, v - od pierwszego do drugiego wystąpienia powtarzającego się stanu, w - od drugiego wystąpienia powtarzającego się stanu do końca słowa y . Łatwo zauważyć, że na schemacie automatu słowu v odpowiada pętla, czyli v 6= ε oraz δ ? (q0 , xu) = δ ? (q0 , xuv ): v δ ? (q0 , xu) u
w
q0 x
y
z V1.1 – 39/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Języki regularne
Lemat o pompowaniu dla języków regularnych
Szkic dowodu ciąg dalszy: Oznacza to iż dla dowolnego i ≥ 0 mamy: δ ? (q0 , xuv i )
= δ ? (δ ? (q0 , xuv ), v i−1 ) = = δ ? (δ ? (q0 , xu), v i−1 ) = = δ ? (q0 , xuv i−1 ) = .. . = δ ? (q0 , xu)
Ostatecznie otrzymuje się δ ? (q0 , xuv i wz) = δ ? (q0 , xuvwz) ∈ F ostatecznie xuv i wz ∈ L.
V1.1 – 40/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Języki regularne
Lemat o pompowaniu – gra o czterech regułach Gra dla dwóch osób. Gracz A stara się pokazać, że język nie jest regularny, a gracz B odwrotnie, stara się pokazać, że język mimo wszystko jest regularny. Zasady gry są następujące: 1
gracz B wybiera k ≥ 0. (Jeśli L jest faktycznie regularny, to gracz B może wybrać za k liczbę stanów automatu akceptującego język L),
2
gracz A wybiera słowa x, y , z, takie że xyz ∈ L i |y | ≥ k. Jeśli takie słowa nie istnieją, czyli nie można wykonać ruchu, to gracz A przegrywa,
3
gracz B dzieli y na takie słowa u, v , w , y = uvw , że v 6= ε. (Jeśli L jest faktycznie regularny, to gracz B może podzielić y na pierwszych dwóch wystąpieniach stanu, który jako pierwszy powtarza się w trakcie wczytywania słowa y.),
4
gracz A wybiera i ≥ 0.
Jeśli xuv i wz ∈ / L, to wygrał gracz A, w przeciwnym przypadku wygrał gracz B. V1.1 – 41/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Języki regularne
Lemat o pompowaniu – przykłady
Język L = {an b n : n ≥ 0} nie jest regularny: Gracz B, wybiera k, Gracz A, x = ε, y = ak i z = b k , Jakkolwiek gracz B by nie podzielił słowa y , to słowo v składa się wyłącznie z literek a i jest niepuste. Gracz A może wybrać i = 2. Słowo xuv 2 wz ∈ / L, gdyż w słowie występuje więcej liter a niż b, czyli wygrał gracz A.
V1.1 – 42/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Języki regularne
Przykłady praktyczne – FLEX/LEX Specyfikacja analizatora w programie Lex składa się z trzech części: deklaracji programistycznych (stałych i zmiennych) oraz definicji regularnych, reguł rozpoznawania leksemów, dodatkowych procedur zdefiniowanych przez użytkownika. Poszczególne części są oddzielone od siebie wierszami przy użyciu: %%. Łatwy przykład na początek: %{ #include %} %% "FOO" { printf("słowo: Foo\n"); } "BAR" { printf("słowo: Bar\n"); } "FOOBAR" { printf("słowo: Foobar\n"); } %% int main() { yylex(); return 0; } V1.1 – 43/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Języki regularne
WC – word count Przykład zliczający ilość linii oraz znaków: %{ #include int num_lines = 0, num_chars = 0; %} %% \n ++num_lines; ++num_chars; . ++num_chars; %% int main () { yylex (); printf ("There were %d lines and %d characters.\n", num_lines, num_chars); return 0; }
V1.1 – 44/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Języki regularne
Odczyt wartości liczbowych Odczytywanie wartości liczbowych: %{ #include %} digit [0-9] digits {digit}+ fractional "."{digits} sign_opt ("+"|"-")? exp_opt ((e|E){sign_opt}{digits})? number {sign_opt}({digits}{fractional} | {digits}"."?|{fractional}){exp_opt} %% {number} { printf("liczba: %f\n",atof(yytext)); } . { /* pusta operacja */ } %% V1.1 – 45/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Języki regularne
Odczyt wartości liczbowych i szyfr Cezara Pozostała funkcja main: int main() { yylex(); printf("\n"); return 0; } Krótki przykład dla szyfru Cezara: %% [a-z] { char ch = yytext[0]; ch += 3; if (ch > ’z’) ch -= (’z’+1-’a’); printf ("%c", ch); } %% Funkcja main może przedstawiać się tak jak poprzednio. V1.1 – 46/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Języki regularne
Odczyt wartości całkowitych Odczyt wartości całkowitych i obliczanie sumy odczytanych wartości: %{ #include #define NUMBER 1234 int attr; %} INTEGER -?[0-9]+ %% {INTEGER} { attr = atoi(yytext); return NUMBER; } . | \n { /* Nic */ } %% V1.1 – 47/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
Języki regularne
Odczyt wartości całkowitych
Odczyt wartości całkowitych i obliczanie sumy odczytanych wartości, postać funkcji main: int main() { int sum=0; while (yylex() == NUMBER) sum += attr; printf("suma = %d\n",sum); return 0; }
V1.1 – 48/ 49
Wprowadzenie
Automaty niedeterministyczne
Języki regularne
A za tydzień na wykładzie
W następnym tygodniu między innymi
1
Znacznie gramatyk
2
Gramatyka regularna
3
Gramatyka bezkontekstowa
4
Analizatory gramatyczne
5
Drzewa wyprowadzeń
6
Przykład praktyczny - kalkulator
Dziękuje za uwagę!!!
V1.1 – 49/ 49
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Gramatyki regularne i bezkontekstowe Osoba prowadząca wykład i ćwiczenia: dr inż. Marek Sawerwain Instytut Sterowania i Systemów Informatycznych Uniwersytet Zielonogórski e-mail : [email protected] tel. (praca) : 68 328 2321, pok. 328a A-2, ul. prof. Z.Szafrana 2, 65-246 Zielona Góra
Ostatnia zmiana: 10.12.2012
V1.0 – 1/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Spis treści 1
Wprowadzenie Plan wykładu
2
System przepisywania Definicja Wyprowadzanie System przepisywania – język
3
Gramatyki Klasyfikacja Chomsky’ego Gramatyka bezkontekstowa Drzew wyprowadzeń Jednoznaczność gramatyki Notacja BNF Gramatyka regularna
4
Praktyka
5
A za tydzień na wykładzie
V1.0 – 2/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Plan wykładu
Plan wykładu – spotkania tydzień po tygodniu
(1) Informacje o wykładzie, poprawność algorytmów (2) Poprawność algorytmów – logika Hoarego (3) Analiza złożoności kodu wysokiego i niskiego poziomu (4) Modele algorytmiczne – maszyny proste, obwody logiczne (5) Modele algorytmiczne – maszyna Turinga oraz rachunek-λ (6) Automaty (nie)deterministyczne – część I (7) Automaty (nie)deterministyczne – część II (8) ⇒ Gramatyki regularne i bezkontekstowe ⇐
V1.0 – 3/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Plan wykładu
Plan wykładu – spotkania tydzień po tygodniu
(9) Gramatyki i automaty ze stosem (10) Algorytmy równoległe (11) Klasy złożoności obliczeniowej (12) Pamięć logarytmiczna i wielomianowa (13) Problemy NP-zupełne (14) Wstęp do obliczeń kwantowych (15) Wybrane algorytmy kwantowe
V1.0 – 4/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Plan wykładu
Plan wykładu
1
system przepisywania 1 2 3
2
gramatyki 1 2 3 4 5
3
definicja przykład język ogólna definicja gramatyki, definicja formalna, równoważność gramatyk, klasyfikacja Chomskiego, gramatyka bezkontekstowa
kalkulator RPN i „normalny”
V1.0 – 5/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Plan wykładu
Materiały wykorzystane podczas tworzenia tego wykładu, a także przydatne do dalszych studiów: 1
John E.Hopcroft, Jeffrey D.Ullman: Wprowadzenie do teorii automatów, języków i obliczeń, Wydawnictwo Naukowe PWN 2003 Wydanie 1 oraz Wydanie 2 z roku 2006,
2
przedmiot Języki automaty i obliczenia z Ważniaka,
3
dokumentacja programów Flex oraz Bison,
4
wykład M.Kubicy, Języki formalne i automaty, http://www.mimuw.edu.pl/~kubica/aug/index-frames.html
V1.0 – 6/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
System przepisywania
V1.0 – 7/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Definicja
System przepisywania – definicja System przepisywania (ang. rewrite system – RS): System przepisujący – definicja System przepisujący jest to para RS = (A, P), gdzie A jest dowolnym skończonym alfabetem, P ⊆ A? × A? - skończoną relacją inaczej zbiorem praw. Ogólnie fakt, że para (u, v ) ∈ P, będzie zapisywane jako u → v ∈ P i nazywać to będziemy prawem przepisywania lub produkcją w systemie RS. Jeśli RS = (A, P) jest dowolnym systemem przepisującym, a x, y ∈ A? dowolnymi słowami, to system RS przepisuje słowo x na słowo y (generuje y ze słowa x) bezpośrednio, co oznacza się symbolem x 7→ y , jeśli istnieją takie słowa x1 , x2 ∈ A∗ oraz prawo u → v ∈ P takie, że x = x1 ux2 , y = x1 vx2 .
V1.0 – 8/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Wyprowadzanie
System przepisywania – wyprowadzanie Przepisanie słowa pośrednie (symbol 7→ reprezentuje relację, natomiast 7→? , domknięcie przechodnio-zwrotne tej relacji): System RS przepisuje słowo x na słowo y (generuje y ze słowa x), co oznacza się symbolem x 7→? y , jeśli istnieją słowa w0 , w1 , . . . , wk ∈ A? oraz k ≥ 0 takie, że w0 = x, wk = y , wi 7→ wi+1 dla i = 0, 1, . . . , k − 1. Ciąg (w0 , w1 , ..., wk ) nazywa się wyprowadzeniem w systemie RS. Liczba k określa długość wyprowadzenia. Wyprowadzenie można również oznaczyć w następujący sposób: w0 7→ w1 7→ . . . 7→ wk Dla RS = ({a, b, c}, {(ba, ab), (ca, ac), (cb, bc)}) można wyprowadzić ze słowa cabbac słowo aabbcc: cabbac 7→(ca,ac) acbbac 7→(cb,bc) abcbac 7→(cb,bc) abbcac 7→(ca,ac) abbacc 7→(ba,ab) ababcc 7→(ba,ab) aabbcc V1.0 – 9/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
System przepisywania – język
System przepisywania – język
Niech RS = (A, P) będzie dowolnym systemem przepisującym, a B dowolnym, ustalonym podzbiorem A? . językiem generowanym przez RS nazywamy zbiór Lgen (RS, B) = {w ∈ A? : x 7→? w , x ∈ B}, językiem rozpoznawanym przez RS nazywamy zbiór: Lacc (RS, B) = {w ∈ A? : w 7→? x , x ∈ B}. Dla poprzedniego przykład, gdy B = {cab}, to otrzymuje się Lgen (RS, B) = {abc, acb, cab} Lacc (RS, B) = {cab, cba}
V1.0 – 10/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Gramatyka
V1.0 – 11/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Gramatyka
Gramatyczny opis języka L zawiera cztery ważne składowe: 1
Istnieje skończony zbiór symboli tworzących łańcuchy definiowanego języka. Symbole te nazywamy terminalami lub symbolami końcowymi.
2
Istnieje skończony zbiór zmiennych, nazywanych nieterminalami lub kategoriami syntaktycznymi. Każda ze zmiennych przedstawia język, tj. zbiór łańcuchów.
3
Jednak ze zmiennych reprezentuje definiowany język i zwana jest ona symbolem początkowym. Inne zmienne reprezentują pomocnicze klasy łańcuchów używane przy definiowaniu języka symbolu początkowego.
V1.0 – 12/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Gramatyka
4
Istnieje skończony zbiór produkcji lub reguł, przedstawiających rekurencyjną definicję języka. Każda produkcja składa się z: 1
2 3
zmiennej (częściowo) definiowanej przez tę produkcję. Zmienna ta jest często nazywana głową produkcji. symbolu produkcji np.: → Łańcucha złożonego z zera lub więcej terminali i zmiennych. Łańcuch ten, zwany jest ciałem produkcji, przedstawia jeden ze sposobów tworzenia łańcuchów w języku zmiennej będącej głową produkcji. W trakcie tego pozostawiamy terminale bez zmian i podstawiamy za każdą zmienną ciała produkcji dowolny łańcych, o którym wiadomo, że należy do jezyka tej zmiennej.
(wg. J.E. Hopcroft, R.Motwani, J.D. Ullman, Wprowadzenie do teorii automatów, języków i obliczeń, PWN 2005)
V1.0 – 13/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Gramatyka – definicja Gramatyka jest to system G = (V , T , P, S), w którym V 6= ∅ - skończony zbiór symboli nieterminalnych (alfabet nieterminalny), T 6= ∅ - skończony zbiór symboli terminalnych (alfabet terminalny), P ⊆ (V ∪ T )+ × (V ∪ T )? - skończona relacja, zbiór produkcji (praw), S ∈ V - symbol początkowy (startowy). Alfabet terminalny oraz alfabet nieterminalny są rozłącznymi zbiorami, a słowo u występujące po lewej stronie produkcji zawiera co najmniej jeden symbol nieterminalny. Fakt, że para (u, v ) ∈ P, zapisujemy: u → v ∈ P lub u →G v . Definicja języka Językiem generowanym przez gramatykę G = (V , V , P, S) nazywamy zbiór: L(G ) = {x ∈ VT? : S 7→?G x}. V1.0 – 14/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Równoważność gramatyk Niestety, pomiędzy językiem a generującą go gramatyką nie można wskazać wzajemnie jednoznacznej odpowiedniości. Dany język może być generowany przez wiele różnych gramatyk (dość często o bardzo różnej strukturze i własnościach). Dlatego, należy wprowadzić i określić pojęci równoważności językowej dla wskazanych gramatyk. Gramatyki G1 i G2 są równoważne językowo wtedy i tylko wtedy, gdy L(G1 ) = L(G2 ). Przykłady równoważnych gramatyk: 1 gramatyka o postaci G1 = (V , T , P, S), w której V = {S}, T = {a}, P = {S → Sa, S → a}, generuje język określony jako: L(G1 ) = {an : n = 1, 2, . . .}, 2
Gramatyka G2 = (V , T , P, S), w której V = {S}, T = {a}, P = {S → SS, S → a}, generuje język określony jako: L(G2 ) = {an : n = 1, 2, ...}, V1.0 – 15/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Równoważność gramatyk 3
Gramatyka G3 = (V , T , P, S ≡ v0 ), w której V = {v0 , v1 , w , w1 , w2 , z, z1 , z2 , z3 } , T = {a, b, c}, P = {v0 → v0 z1 , v0 → v1 z1 , v1 → aw1 , v1 → av1 w1 , w1 z1 → w1 z3 , w1 z3 → wz3 , wz3 → wz, w1 w → w1 w2 , w1 w2 → ww2 , z2 z → z1 z, ww2 → ww1 , zz1 → z2 z1 , z2 z1 → z2 z, w → b, z → c} generuje język L(G3 ) = {an b n c n : n = 1, 2, . . .}.
4
Gramatyka G4 = (V , T , P, S ≡ v0 ), w której V = {v0 , v1 , v2 }, T = {a, b, c}, P = {v0 → abc, v0 → av1 bc, v1 b → bv1 , v1 c → v2 bcc, bv2 → v2 b, av2 → aav1 , av2 → aa} generuje język L(G4 ) = {an b n c n : n = 1, 2, . . .}. V1.0 – 16/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Klasyfikacja Chomsky’ego
Można wskazać cztery typy gramatyk określonych przez Noama Chomsky’ego. Hierarchia Chomsky’ego Gramatyka G = (V , T , P, S) jest typu (i) dla i = 0, 1, 2, 3 wtedy i tylko wtedy, gdy spełnione są następujące warunki: typ(0): każda gramatyka, spełniająca definicję umieszczoną na slajdzie (14), typ(1): tzw. gramatyka kontekstowa, czyli gramatyka, w której każde prawo ze zbioru P ma postać u1 vu2 → u1 xu2 , gdzie u1 , u2 ∈ (V ∪ T )? , v ∈ V , x ∈ (V ∪ T )+ lub v0 → 1, przy czym, jeśli v0 → 1 ∈ P, to v0 nie występuje po prawej stronie w żadnym prawie produkcji określonym w P, typ(2): bezkontekstowa, czyli gramatyka, w której każde prawo ze zbioru P ma postać v → x, gdzie v ∈ V , x ∈ (V ∪ T )? , typ(3): regularna, czyli gramatyka, w której każde prawo ze zbioru P ma postać v → v 0 x lub v → x, gdzie v , v 0 ∈ V , x ∈ T ? . V1.0 – 17/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Klasyfikacja Chomsky’ego
W oparciu o wprowadzone klasyfikację typu gramatyk można określić odpowiadające im rodziny (albo klasy) języków: L0 – rodzinę wszystkich języków typu 0, L1 – rodzinę wszystkich języków typu 1, czyli języków kontekstowych, L2 – rodzinę wszystkich języków typu 2, czyli języków bezkontekstowych, L3 – rodzinę wszystkich języków typu 3, czyli języków regularnych. Pomiędzy wprowadzonymi klasami języków zachodzą następujące zależności: L3 ⊆ / L2 ⊆ / L1 ⊆ / L0 . Język L jest typu (i) dla i = 0, 1, 2, 3 wtedy i tylko wtedy, gdy jest rozpoznawany przez automat z odpowiedniej rodziny.
V1.0 – 18/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Klasyfikacja Chomsky’ego
Przykłady równoważnych gramatyk i ich przynależność do odpowiednich typów: 1 gramatyka o postaci G1 = (V , T , P, S), w której V = {S}, T = {a}, P = {S → Sa, S → a}, generuje język określony jako: L(G1 ) = {an : n = 1, 2, . . .}, gramatyka typu (3), 2 gramatyka G2 = (V , T , P, S), w której V = {S}, T = {a}, P = {S → SS, S → a}, generuje język określony jako: L(G2 ) = {an : n = 1, 2, ...}, gramatyka typu (2), 3 gramatyka G3 = (V , T , P, S ≡ v0 ), w której V = {v0 , v1 , w , w1 , w2 , z, z1 , z2 , z3 } , T = {a, b, c}, P = {v0 → v0 z1 , v0 → v1 z1 , v1 → aw1 , v1 → av1 w1 , w1 z1 → w1 z3 , w1 z3 → wz3 , wz3 → wz, w1 w → w1 w2 , w1 w2 → ww2 , z2 z → z1 z, ww2 → ww1 , zz1 → z2 z1 , z2 z1 → z2 z, w → b, z → c} 4
generuje język L(G3 ) = {an b n c n : n = 1, 2, . . .}, gramatyka typu (1), gramatyka G4 = (V , T , P, S ≡ v0 ), w której V = {v0 , v1 , v2 }, T = {a, b, c}, P = {v0 → abc, v0 → av1 bc, v1 b → bv1 , v1 c → v2 bcc, bv2 → v2 b, av2 → aav1 , av2 → aa} generuje język L(G4 ) = {an b n c n : n = 1, 2, . . .}, gramatyka typu (0). V1.0 – 19/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Gramatyka bezkontekstowa
Gramatyka bezkontekstowa
V1.0 – 20/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Gramatyka bezkontekstowa
Gramatyka bezkontekstowa – definicja
Gramatyka bezkontekstowa (GBK), to dowolna taka czwórka G = (V , T , P, S), gdzie: V to (skończony) alfabet symboli nieterminalnych, T to (skończony) alfabet symboli terminalnych, V ∩ T = ∅, P to skończony zbiór produkcji, reguły posiadają następującą postać A → α dla A ∈ V , α ∈ (V ∪ T )? , S ∈ V to wyróżniony symbol nieterminalny, symbol startowy. Zazwyczaj podaje się tylko zbiór produkcji. Gdyż, w sposób niejawny z produkcji wynika zbiór nieterminali i terminali. Jeżeli nie będzie to oczywiste, jaki nieterminal jest symbolem startowym, będzie to dodatkowo zaznaczone.
V1.0 – 21/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Gramatyka bezkontekstowa
Gramatyka bezkontekstowa przykłady Przykład gramatyki dla palindromów, przy wykorzystaniu indukcyjnej definicji: podstawa: λ, 0, 1 – są palindromami, krok indukcyjny: jeśli w jest palindromem, to 0w 0, 1w 1 są też palindromami. Żaden inny łańcuch nie jest palindromem zbudowanym z zer oraz jedynek, jeśli nie wynika to z podstawy i kroku indukcyjnego. Gramatyka o postaci G ma postać: G = ({P}, {0, 1}, A, P) Postać produkcji: P P P P P
→ → → → →
λ 0 1 0P0 1P1 V1.0 – 22/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Gramatyka bezkontekstowa
Gramatyka bezkontekstowa przykłady Gramatyka generująca słowa dla języka: {an b n : n ≥ 0}: A → aAb|λ Słowo aaabbb jest generowane w następujący sposób: A → aAb → aaAbb → aaaAbbb → aaabbb Gramatyka generująca palindromy nad alfabetem a, b, c: S → aSa|bSb|cSc|a|b|c|λ Słowo abbcbba jest generowane w następujący sposób: S → aSa → abSba → abbSbba → abbcbba
V1.0 – 23/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Gramatyka bezkontekstowa
Gramatyka bezkontekstowa – własności Niech G = (V , T , P, S) będzie ustaloną gramatyką bezkontekstową. Przez → będziemy oznaczać zbiór produkcji P traktowany jako relacja, ?→⊆ V × (V ∪ T )? . Znaczenie → można rozszerzyć na napisy: →⊆ (V ∪ T )? × (V ∪ T )? A → β ⇒ αAγ → αβγ Domknięcie przechodnio-zwrotne będzie relacji → będzie oznaczane przez →? , i naturalnie →? ⊆ (V ∪ T )? × (V ∪ T )? . Relacja → opisuje pojedyncze zastosowanie produkcji, czyli jako relację między nieterminalem, a zastępującym go słowem. Relacja →? opisuje co można zrobić stosując dowolną liczbę (łącznie z zerem) dowolnych produkcji. Inaczej mówiąc relacja →? to wielokrotnego iterowania relacji →. Jeśli x →? y , to istnieje ciąg słów (zi ) taki, iż: x = z0 → z1 → . . . → zk = y . V1.0 – 24/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Gramatyka bezkontekstowa
Gramatyka bezkontekstowa – własności Gramatyka opisuje język złożony ze wszystkich słów (nad alfabetem terminalnym), które możemy uzyskać stosując produkcje począwszy od symbolu startowego: Język generowany przez GBK Niech G = (V , T , P, S) będzie ustaloną gramatyką bezkontekstową. Język L generowany przez gramatykę G , to: L(G ) = {x ∈ T ? : S →? x} Nieco inaczej, można powiedzieć że L(G ) to zbiór takich słów x ∈ T ? , dla ? których istnieją ciągi słów (zi ) oraz zi ∈ (V ∪ T ) taki, iż: S = z0 → z1 → . . . → zk = x. O ciągu (zi ) powiemy, iż jest to wyprowadzenie słowa x w gramatyce G . Język L jest bezkontekstowy, jeżeli istnieje generująca go gramatyka G . V1.0 – 25/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Drzew wyprowadzeń
Drzew wyprowadzeń Drzewo wyprowadzenia, to ilustracja jak określone słowo może być wyprowadzone w danej gramatyce, w postaci drzewa. Drzewo wyprowadzenia spełnia następujące warunki: w korzeniu drzewa znajduje się symbol startowy, w węzłach wewnętrznych drzewa znajdują się nieterminale, a w liściach terminale lub słowa puste λ, jeśli w danym węźle mamy nieterminal X , a w jego kolejnych pod węzłach mamy x1 , x2 , . . . , xk , to musi zachodzić: X → x1 x2 . . . xk , terminale umieszczone w liściach, czytane od lewej do prawej, tworzą wyprowadzone słowo.
Język {an b n : n ≥ 0}, S → aSb|λ, dla słowa aaabbb, wyprowadzenie jest następujące:
A a a
A → aAb → aaAbb → aaaAbbb → aaabbbb a
A A A
b b b
λ V1.0 – 26/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Drzew wyprowadzeń
Drzew wyprowadzeń Język dla napisów zbudowanych z nawiasów. Poprawne wyrażenia nawiasowe, to takie ciągi nawiasów, w których: 1
łączna liczba nawiasów otwierających oraz zamykających jest taka sama,
2
każdy prefiks wyrażenia nawiasowego zawiera przynajmniej tyle samo nawiasów otwierających, co zamykających.
Gramatyka ma następującą postać:
Drzewo wyprowadzeń dla słowa (()(())): S (
(
S
)
S )
S (
S
) S
( λ
) S
S → (S)|SS|λ λ V1.0 – 27/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Jednoznaczność gramatyki
Jednoznaczność gramatyki Gramatyka G jest jednoznaczna, gdy dla każdego słowa x ∈ L(G ) istnieje tylko jedno drzewo wyprowadzenia słowa x w ramach gramatyki G . Jeśli gramatyka G jest gramatyką jednoznaczna, to drzewa wyprowadzeń określają strukturę (składniową) słów z języka w sposób jednoznaczny. Co prawda słowa mogą mieć wiele wyprowadzeń, ale różnią się one tylko kolejnością stosowanych produkcji, a nie strukturą wyprowadzonego słowa. Poniższa gramatyka tworząca wyrażenia arytmetyczne niestety nie jest jednoznaczna: S L C
→ → →
S + S|S − S|S ∗ S|S/S|L|(S) C |CL 0|1|2|3|4|5|6|7|8|9
V1.0 – 28/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Jednoznaczność gramatyki
Dwa drzewa wyprowadzeń dla wyrażenia 42 + 5 · 2:
V1.0 – 29/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Jednoznaczność gramatyki
Poniższa gramatyka tworząca wyrażenia arytmetyczne jest już jednoznaczna: E S F L C
→ → → → →
E + S|E − S|S S ∗ F |S/F |F L|(E ) C |CL 0|1|2|3|4|5|6|7|8|9
V1.0 – 30/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Notacja BNF
BNF – definicja Poszczególne konstrukcje składniowe w notacji BNF są definiowane w następujący sposób: < nazwa konstrukcji >::= wyrażenie opisujące konstrukcję Symbole ujęte w nawiasy ostre reprezentują symbole nieterminalne, czyli zmienne leksykograficzne. Wyrażenie po znaku przypisania ::= może zawierać sekwencje innych symboli zawierających zarówno symbole nieterminalne oraz terminalne. Do każdej zmiennej można przypisać kilka wyrażeń rozdzielonych za pomocą pionowej kreski |. A dokładnej podstawowe elementy w definicji są następujące: < konstrukcja > - nazwy konstrukcji, w tym również definiowanej, co oznacza że zależności rekurencyjne są dozwolone, tekst, ujęty w cudzysłów, to tekst który pojawia się dosłownie w danej konstrukcji, . . . | . . . - oddziela różne alternatywne postaci danej konstrukcji, [. . .] - fragment ujęty w kwadratowe nawiasy jest opcjonalny. V1.0 – 31/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Notacja BNF
Przykładem zastosowania notacji BNF może być np.: poniższy opis gramatyki adresu domu/mieszkania jaki jest stosowany w Stanach Zjednoczonych: < postal − addr > < personal − part > < name − part >
::= ::= ::=
< street − addr > < zip − part >
::= ::=
< name − part >< street − addr >< zip − part > < first − name > | < initial >00 .00 < personal − part >< last − name > [< jr − part >] < EOL > | < personal − part >< name − part > [< apt >] < house − num >< street − name >< EOL > < town − name >00 ,00 < state − code >< ZIP − code >< EOL >
Jeszcze jeden opis gramatyki adresu zamieszkania: ::= ::= ["W.P." | "Sz.Pan."] "," ::= ["/" ] ["m" | "/" ]"," ::=[ ] ::=["," ] ::= "–" ::="0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ::= [ ]
V1.0 – 32/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Notacja BNF
Zasady notacji BNF można zapisać za pomocą samej notacji BNF, co przedstawia się następująco: < syntax > < rule >
::= ::=
< expr > < or − expr > < list − expr >
::= ::= ::=
< whitespace > < line − end >
::= ::=
< rule > [< syntax >] < whitespace >00 <00 < rule − name >00 >00 < whitespace >00 ::=00 < expr >< whitespace >< line − end > < whitespace >< or − expr > < whitespace >< list − expr > [00 |00 < or − expr >] < whitespace > (00 <00 < rule − name >00 >00 | < QUOTE >< text >< QUOTE > |00 (00 < expr >00 )00 |00 [00 < expr >00 ]00 )[< list − expr >] [00 _00 < whitespace >] [< whitespace >] < EOL > [< line − end >]
Istnieją także inne warianty zapisu notacji BNF, gdzie stosowane są oznaczenia krotności ∗ oraz +. Jednakże, zaprezentowana powyżej notacja jest najczęściej spotykana i bezpośrednio odnosi się do gramatyki bezkontekstowej.
V1.0 – 33/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Gramatyka regularna
Język regularny i gramatyka bezkontekstowa Wszystkie języki regularne, są także językami bezkontekstowami, jednak stwierdzenie odwrotne nie jest prawdziwe np.: L : an b n język jest bezkontekstowy ale nie jest regularny. Gramatyka liniowa Gramatyka (prawostronnie) liniowa, to taka, w której wszystkie produkcje mają postać: A → αB lub A → λ, dla A, B ∈ V oraz α ∈ T ? . Gramatyka silnie liniowa Gramatyka silnie (prawostronnie) liniowa, to taka, w której wszystkie produkcje mają postać: A → αB lub A → λ, dla A, B ∈ V oraz α ∈ T . Twierdzenie Gramatyki (silnie) liniowe opisują klasę języków regularnych.
V1.0 – 34/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Gramatyka regularna
Przekształcenie gramatyki liniowej na silnie liniową Reguły przekształcania: Należy zastąpić produkcje postaci A → a1 . . . ak B (dla k > 1) oraz produkcje postaci A → B, równoważnymi produkcjami odpowiednimi dla gramatyki silnie liniowej. Jeśli mamy w gramatyce produkcję postaci A → B, to dla każdej produkcji o postaci B → α dodajemy do gramatyki produkcję A → α. Krok ten powtarzamy tak długo, jak długo wprowadza on nowe produkcje. Następnie usuwamy wszystkie produkcje postaci A → B. W ten sposób uzyskujemy gramatykę generującą ten sam język, ale nie zawierającą produkcji postaci A → B. Dla każdej produkcji postaci: A → a1 . . . ak B, dla (k > 1), dodaje się nowe symbole terminalne A1 , . . . , Ak−1 w następujący sposób: A A1
→ a1 A1 → a2 A2 .. .
Ak−1
→ ak B V1.0 – 35/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Gramatyka regularna
Przekształcenie gramatyki liniowej na silnie liniową Reguły przekształcania, cd: Podobnie postępuje się dla każdej produkcji postaci: A → a1 . . . ak , dla (k > 1): A → a1 A1 A1 → a2 A2 .. . Ak−1 Ak
→ ak Ak → λ
Ogólnie, zawsze można: 1
gramatykę liniową przekształcić do silnie liniowej,
2
gramatykę silnie liniową przekształcić na automat niedeterministyczny,
3
automat niedeterministyczny przekształcić na gramatykę silnie liniową.
V1.0 – 36/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Gramatyka regularna
Automat niedeterministyczny akceptujący język (ab)? |(aa)? : a
P a
b
Q
S a R
a
T
a
Gramatyka silnie liniowa: Gramatyka liniowa: S Q T
→ abQ|aaT |λ → abQ|λ → aaT |λ
Wyprowadzenie: S → abQ → ababQ → abab.
S P Q R T
→ → → → →
aP|aR|λ bQ aP|λ aT aR|λ
Wyprowadzenie: S → aP → abQ → abaP → ababQ → abab. V1.0 – 37/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Czas na trochę praktyki: YACC albo BISON Bison, to narzędzie do tworzenia „parser’ów”, analizatorów składniowych opartych o gramatykę bezkontekstową. Ogólna postać jest podobna do programy LEX/FLEX: %{ Prologue %} Bison declarations %% Grammar rules %% Epilogue
V1.0 – 38/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Kalkulator RPN
Przykłady w RPN dla pakietu Bison: 4 9 + 13 3 7 + 3 4 5 * + -13 3 7 + 3 4 5 * + - n 13 5 6 / 4 n + -3.166666667 3 4 ^ 81 ^D
Note the unary minus, ‘n’
Exponentiation End-of-file indicator
V1.0 – 39/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Program dla Bisona Początek pliku dla Bisona: %{ #include #include #include #define YYSTYPE double int yylex (void); void yyerror (char const *); %} %token NUM
V1.0 – 40/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Gramatyka dla Bisona Gramatyka dla wyrażeń w odwrotnej notacji polskiej (ang. reverse polish notation – RPN): input: /* empty */ | input line ; line: ’\n’ | exp ’\n’ ; exp: NUM | exp | exp | exp | exp | exp | exp ;
exp exp exp exp exp ’n’
{ printf ("%.10g\n", $1); }
’+’ ’-’ ’*’ ’/’ ’^’
{ { { { { { {
$$ $$ $$ $$ $$ $$ $$
= = = = = = =
$1; } $1 + $2; } $1 - $2; } $1 * $2; } $1 / $2; } pow ($1, $2); } -$1; }
V1.0 – 41/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Analiza leksykalna Analiza leksykalna za pomocą własnej funkcji yylex: int yylex (void) { int c; while ((c = getchar ()) == ’ ’ || c == ’\t’) continue; if (c == ’.’ || isdigit (c)) { ungetc (c, stdin); scanf ("%lf", &yylval); return NUM; } if (c == EOF) return 0; return c; }
V1.0 – 42/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
„Normalny” kalkulator Początek pliku dla Bisona w kalkulatorze „infinixowym”: %{ #define YYSTYPE double #include #include int yylex (void); void yyerror (char const *); %} %token NUM %left ’-’ ’+’ %left ’*’ ’/’ %left NEG /* negation--unary minus */ %right ’^’ /* exponentiation */ V1.0 – 43/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
Gramatyka „normalnego” kalkulatora – 2 + 3 = 5 input: /* empty */ | input line ; line: ’\n’ | exp ’\n’ ; exp: NUM | exp ’+’ | exp ’-’ | exp ’*’ | exp ’/’ | ’-’ exp | exp ’^’ | ’(’ exp ;
{ printf ("\t%.10g\n", $1); }
{ $$ = $1; exp { $$ = $1 + $3; } exp { $$ = $1 - $3; } exp { $$ = $1 * $3; } exp { $$ = $1 / $3; } %prec NEG { $$ = -$2; } exp { $$ = pow ($1, $3); } ’)’ { $$ = $2; }
}
V1.0 – 44/ 45
Wprowadzenie
System przepisywania
Gramatyki
Praktyka
A za tydzień na wykładzie
W następnym tygodniu między innymi
1
postać normalna Chomsky’ego,
2
algorytm CYK,
3
automaty stosowe,
4
interpreter języka.
Dziękuje za uwagę!!!
V1.0 – 45/ 45
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Gramatyki i automaty ze stosem Osoba prowadząca wykład i ćwiczenia: dr inż. Marek Sawerwain Instytut Sterowania i Systemów Informatycznych Uniwersytet Zielonogórski e-mail : [email protected] tel. (praca) : 68 328 2321, pok. 328a A-2, ul. prof. Z.Szafrana 2, 65-246 Zielona Góra
Ostatnia zmiana: 03 grudnia 2013
V1.1 – 1/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Spis treści 1
Wprowadzenie Plan wykładu
2
Postać normalna Chomsky’ego
3
Algorytm CYK Lemat o pompowaniu dla j. bezkontekstowych
4
Automaty ze stosem Automaty ze stosem – ogólne spojrzenie Automaty ze stosem – definicja formalna Równoważność gramatyk bezkontekstowych i automatów stosowych
5
Interpreter języka
6
A za tydzień na wykładzie
V1.1 – 2/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Plan wykładu
Plan wykładu – spotkania tydzień po tygodniu
(1) Informacje o wykładzie, poprawność algorytmów (2) Poprawność algorytmów – logika Hoarego (3) Analiza złożoności kodu wysokiego i niskiego poziomu (4) Modele algorytmiczne – maszyny proste, obwody logiczne (5) Modele algorytmiczne – maszyna Turinga oraz rachunek-λ (6) Automaty (nie)deterministyczne – część I (7) Automaty (nie)deterministyczne – część II (8) Gramatyki regularne i bezkontekstowe
V1.1 – 3/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Plan wykładu
Plan wykładu – spotkania tydzień po tygodniu
(9) ⇒ Gramatyki i automaty ze stosem ⇐ (10) Algorytmy równoległe (11) Klasy złożoności obliczeniowej (12) Pamięć logarytmiczna i wielomianowa (13) Problemy NP-zupełne (14) Wstęp do obliczeń kwantowych (15) Wybrane algorytmy kwantowe
V1.1 – 4/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Plan wykładu
Plan wykładu
1
własności gramatyk 1 2 3 4
2
postać normalna Chomsky’ego algorytm Cocke, Younger’a i Kasami’ego przykłady testów przynależności do j. bezkontekstowego lemat o pompowaniu dla j. bezkontekstowych
automaty ze stosem 1 2 3
definicja przykłady równoważność GBK i automatów ze stosem
V1.1 – 5/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Plan wykładu
Materiały wykorzystane podczas tworzenia tego wykładu, a także przydatne do dalszych studiów: 1
John E.Hopcroft, Jeffrey D.Ullman: Wprowadzenie do teorii automatów, języków i obliczeń, Wydawnictwo Naukowe PWN 2003 Wydanie 1 oraz Wydanie 2 z roku 2006,
2 3
Ważniakowy przedmiot, „Języki automaty i obliczenia”, wykład M.Kubicy, Języki formalne i automaty, http://www.mimuw.edu.pl/~kubica/aug/index-frames.html
4
dokumentacja do programów Flex oraz Bison.
V1.1 – 6/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Postać normalna Chomsky’ego
V1.1 – 7/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Postać normalna Chomsky’ego
Postać normalna Chomsky’ego (PNC) ma dwa ważne zastosowania: pozwala na sprowadzenie każdej gramatyki bezkontekstowej do ujednoliconej postaci, co pozwala na np.: podanie jednej implementacji w danym języku programowania, która jest zdolna do pracy z gramatykami bezkontekstowymi o różnym przeznaczeniu ale o tej samej postaci wyrażonej w postacią normalną Chomsky’ego, gramatyka w PNC pozwala także na podanie efektywnego algorytmu dającego odpowiedź, czy dane słowo należy do języka bezkontekstowego.
V1.1 – 8/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Postać normalna Chomsky’ego
Postać normalna Chomsky’ego Gramatyka G jest w postaci normalnej Chomsky’ego, jeżeli wszystkie produkcje w gramatyce G są o postaci: A → BC lub A → a dla nieterminali A, B i C oraz symbolu terminala a) Gdy gramatyka jest w postaci normalnej Chomsky’ego, to każda produkcja przekształca jeden symbol nieterminaly na dwa nieterminale, bądż jeden symbol nieterminaly na jeden symbol terminalny. Twierdzenie Dla dowolnej gramatyki bezkontekstowej G istnieje taka gramatyka bezkontekstowa w postaci normalnej Chomsky’ego G 0 , gdzie L(G 0 ) = L(G ) \ {λ}.
V1.1 – 9/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Postać normalna Chomsky’ego – dowód/konstrukcja Dla G = (V , T , P, S), konstrukcja G 0 w postaci Chomsky’ego jest realizowana w następujący sposób: 1 gramatyka G1 = (V , T , P1 , S), reprezentuje gramatykę powstałą z G poprzez domknięcie zbioru produkcji zgodnie z poniższymi regułami: dla produkcji o postaci X → αY β i Y → λ (dla X , Y ∈ V i α, β ∈ (V ∪ T )? ), dodaje się produkcję X → αβ. Nowa produkcja realizuje w jednym kroku to, co wcześniej było realizowane w dwóch krokach: X → αY β → αβ, dla produkcji o postaci X → Y i Y → γ (dla X , Y ∈ V i γ ∈ (V ∪ T )? ), dodaje się produkcję X → γ. Nowa produkcja realizuje w jednym kroku to, co wcześniej było realizowane w dwóch krokach: X → Y → γ. Stosowanie powyższych reguł jest powtarzane tak długo, jak długo wprowadzane są jakiekolwiek nowe produkcje. Ponieważ dodawane produkcje nie są dłuższe od już istniejących, toteż cały proces doda ograniczoną liczbę produkcji i się zakończy po skończonej liczbie dodanych nowych produkcji. Należy też zauważyć, że L(G1 ) = L(G ), gdyż dodawane produkcje nie pozwalają wyprowadzić niczego nowego, ponad to, co było możliwe do wyprowadzenia poprzednio. V1.1 – 10/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Postać normalna Chomsky’ego – dowód/konstrukcja 2
dla dowolnego słowa z x ∈ L(G1 ), x 6= λ należy rozważyć jego najkrótsze wyprowadzenie. W takim wyprowadzeniu nie będą się pojawiały produkcje o postaci: X → λ ani X → Y . Niech G2 = (V , T , P2 , S) będzie gramatyką powstałą z G1 przez usunięcie produkcji, gdzie P2 = P1 \ {X → λ, X → Y : X , Y ∈ V }, oraz, naturalnie L(G2 ) = L(G1 ) \ {λ} = L(G ) \ {λ},
3
gramatyka G3 powstaje z G2 poprzez dodanie dla każdego terminala a, b, c, . . . ∈ V , odpowiadającego mu nowego nieterminala (A, B, C , . . .), oraz produkcji: A → a, B → b, C → c, . . .. We wszystkich pozostałych produkcjach X → α, gdzie |α| > 1, zmieniono wszystkie terminale na odpowiadające im nieterminale. Podobnie jak poprzednio L(G3 ) = L(G2 ) = L(G ) \ {λ}, natomiast w G3 istnieją tylko dwa rodzaje produkcji: X → a, gdzie a jest terminalem, oraz X → Y1 Y2 . . . Yk gdzie Yi to nieterminale i k > 1, V1.1 – 11/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Postać normalna Chomsky’ego – dowód/konstrukcja 4
gramatyka G4 powstaje z G3 przez zastąpienie każdej produkcji postaci X → Y1 Y2 . . . Yk (dla k > 2) przez zestaw produkcji: X X1
→ Y1 X1 → Y2 X2 .. .
Xk−2
→ Yk−1 Yk
gdzie X1 , X2 , . . . , Xk>2 to nowe nieterminale dodane do G4 . Uzyskana gramatyka generuje dokładnie ten sam język — naturalnie, zamiast zastosowania jednej produkcji, wprowadzono kilka nowych produkcji, ostatecznie, L(G4 ) = L(G3 ) = L(G ) \ {λ}. gdzie G4 jest szukaną postacią G 0 . V1.1 – 12/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Postać normalna Chomsky’ego – przykład Konwersja na postać normalną Chomsky’ego poniższej gramatyki generującej słowa z języka {an b n : n ≥ 0}: S → aSb|λ W kroku pierwszym usuwamy jest symbol λ, poprzez podanie dodatkowe produkcji: S → aSb|ab|λ co pozwala na usunięcie λ: S → aSb|ab Następnie dodawane są dwa nieterminale A i B, aby zastąpić w istniejących produkcjach terminale a i b, naturalnie należy dodać produkcje A → a i B → b: S → ASB|AB A → a B → b V1.1 – 13/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Postać normalna Chomsky’ego – przykład
W ostatnim kroku algorytmu należy produkcję S → ASB podzielić na dwie produkcje: S → AX |AB X → SB A → a B → b Uzyskana gramatyka jest w postaci normalnej Chomsky’ego, co znajduje potwierdzenie min. we wyprowadzenie słowa aaabbb: S
→ AX → ASB → aSB → aSb → → aAXb → aASBb → aaSBb → aaSbb → → aaABbb → aaaBbb → aaabbb
V1.1 – 14/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Postać normalna Chomsky’ego – przykład Gramatyka generująca poprawne wyrażenia z nawiasami: S → [S]|SS|λ Pierwszy krok, to dodanie dwóch produkcji: S → [] oraz S → S S → [S]|[]|SS|S|λ Usunięcie nadmiarowych produkcji: S → [S]|[]|SS Następnie (krok trzeci) dodane zostaną nieterminale L i P, i zastąpione nimi w istniejących produkcjach terminale [ i ]. Wprowadzone zostaną dwie produkcje L → [ i P →]: S L P
→ → →
LSP|LP|SS [ ] V1.1 – 15/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Postać normalna Chomsky’ego – przykład W ostatnim kroku produkcja S → LSP, jest podzielona na dwie produkcje: S X L P
→ → → →
LX |LP|SS SP [ ]
Uzyskana gramatyka jest w postaci normalnej Chomsky’ego, co znajduje potwierdzenie min. we wyprowadzenie słowa [[][[]]]: S
→ → → →
LX → LSP → [SP → [S] → [SS] → [LPS] → [[PS] → [[]S] → [[]LX ] → [[]LSP] → [[][SP] → [[][S]] → [[][LP]] → [[][[P]] → [[][[]]]
V1.1 – 16/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Algorytm Cocke, Younger’a i Kasami’ego (algorytm CYK) Algorytm Cocke, Younger’a i Kasami’ego (algorytm CYK) umożliwia stwierdzenie, czy dane słowo x jest wyprowadzalne w danej gramatyce G która znajduje się w postaci normalnej Chomsky’ego. Niech G = (V , T , P, S) będzie gramatyką w postaci normalnej Chomsky’ego, a słowo x ∈ T ? będzie znajdować się w postaci x = a1 a2 a3 . . . an . Dla każdej pary indeksów 1 ≤ i ≤ j ≤ n należy wyznaczyć takie nieterminale X, z których można wyprowadzić podsłowo ai . . . aj , inaczej mówiąc powstaje tablica: T [i, j] = {X ∈ V : X →? ai . . . aj } Po wypełnieniu tablicy słowo x jest wyprowadzalne w gramatyce G wtedy i tylko wtedy gdy S ∈ T [1, n].
V1.1 – 17/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Algorytm Cocke, Younger’a i Kasami’ego (algorytm CYK) Wypełnianie tablicy T [i, j] (opis metody jest zależny, czy zaczniemy od przekątnej, czy też od pierwszego górnego wiersza, zakładamy że zaczynamy od przekątnej): na przekątnej T [i, i] umieszcza się nieterminale z których można wyznaczyć terminal ai . Przy czym wyprowadzenie może składać się tylko z jednej produkcji która zastępuje nieterminal symbolem terminalnym: T [i, i] = {X : X → ai ∈ P} należy wypełniać kolejne elementy które znajdują się przy przekątnej. Pamiętając, iż jeśli X →? ai . . . aj i i < j, to wyprowadzenie ma postać X → YZ , Y →? ai . . . ak , Z →? ak+1 . . . aj , dla pewnego k, i ≤ k < j. Obliczając wartość T [i, j] należy uwzględnić wszystkie możliwe punkty podziału k podsłowa aj , . . . , aj : [ T [i, j] = T [i, k] ⊗ T [k + 1, j] i ≤k
gdzie operacja ⊗ jest określona jako: A ⊗ B = {X : X → YZ ∈ P, Y ∈ A, A ∈ B}, inaczej mówiąc wyznaczany jest zbiór wszystkich możliwych nieterminali X na podstawie możliwych Y oraz Z . V1.1 – 18/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Algorytm CYK – przykłady Dla gramatyki, → → →
S A B
SS|AB AS|AA|a SB|BB|b
chcemy sprawdzić czy aabbab jest poprawnie generowane. Generowanie tabeli przedstawia się następująco: 1 a
1
a
2
b
3
b
4
a
5
b
6
2
3
4
5
6
A A B B A B
1 a
1
a
2
b
3
b
4
a
5
b
6
2
3
4
5
6
A A AS
1
2
3
1
A S
a
2
A S BS
B
b
3
B B
b
4
B
a
5
b
6
B A B
A A AS
4
a
5
6
ABS
A B
V1.1 – 19/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Algorytm CYK – przykłady
Dla gramatyki, S A B
→ → →
SS|AB AS|AA|a SB|BB|b
chcemy sprawdzić czy aabbab jest poprawnie generowane. Pozostałe kroki w generowaniu tabeli przedstawiają się następująco: 1
2
3
A A AS
4
5
6
a
1
A
a
2
b
3
b
4
B
a
5
A S
b
6
B
1
2
3
A A AS
4
5
6
a
1
A S BS
a
2
A S BS
B B
b
3
B B
b
4
B
a
5
A S
b
6
B
ABS
ABS
A AS S
V1.1 – 20/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Algorytm CYK – przykłady Dla gramatyki G, generującej słowa {an b n |n ≥ 1} o postaci S S C A B
→ → → → →
AB AC SB a b
chcemy sprawdzić czy słowa aabbb oraz aaabbb przynależą do gramatyki G : S
C
C
S
S
C
C
S A A B B B a
a b
b b
S A A A B B B a
a a
b b
b V1.1 – 21/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Lemat o pompowaniu dla j. bezkontekstowych
Lemat o pompowaniu dla j. bezkontekstowych
Lemat o pompowaniu dla j. bezkontekstowych podobnie jak jego odmiana dla języków regularnych służy do sprawdzenia, czy dany język może należeć do grupy j. bezkontekstowych. Niech L będzie językiem bezkontekstowym. Istnieje wówczas taka stała k > 0, że dla każdego słowa z ∈ L o długości |z| ≥ k można słowo z podzielić na pięć części: z = uvwxy w taki sposób, iż: vx 6= λ, |vwx| ≤ k oraz dla każdego i ≥ 0 zachodzi uv i wx i y ∈ L. Jeśli L będzie językiem bezkontekstowym, to L zawiera dowolnie długie słowa, toteż w drzewach wyprowadzeń tych słów muszą istnieć fragmenty, które się powielają. Powielanie „pompuje” długość słowa należącego do języka L.
V1.1 – 22/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Lemat o pompowaniu dla j. bezkontekstowych
Lemat o pompowaniu dla j. bezkontekstowych Zastosowanie w praktyce, gra dla dwóch osób. Gracz A stara się pokazać że język nie jest bezkontekstowy, natomiast gracz B odwrotnie, stara się wykazać bezkontekstowość języka. 1
gracz B wybiera k > 0. (Jeśli L jest faktycznie bezkontekstowy, to gracz B może wybrać za k = 2|N| .),
2
gracz A wybiera takie słowo z ∈ L, że |z| ≥ k,
3
gracz B dzieli słowo z na słowa u, v , w , x, y , takie że uvwxy = z, gdzie vx 6= λ i |vwx| ≤ k (jeśli L jest istotnie bezkontekstowy, to może to być podział wyznaczony przez powtarzający się symbol nieterminalny na pewnej ścieżce od liścia do korzenia), gracz A wybiera i ≥ 0.
4
Jeśli uv i wx i y ∈ / L, to wygrał gracz A, w przeciwnym przypadku wygrał gracz B.
V1.1 – 23/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Lemat o pompowaniu dla j. bezkontekstowych
Lemat o pompowaniu – przykład
Język L = {an b n c n : n ≥ 0} nie jest językiem bezkontekstowym, gra, czyli odmiana lematu o pompowaniu jest następująca: gracz B wybiera k, gracz A wybiera słowo z = ak b k c k , gracz B dzieli słowo z = uvwxy , gracz A wybiera i = 2. Wiadomo, że |vwx| ≤ k i vx 6= λ, toteż słowa v oraz x mogą zwierać jeden rodzaj symboli bądź dwa, lecz nie wszystkie trzy. Nie może zachodzi fakt iż liczba symbol a, b, c jest taka sama w słowie: uv i wx i y , uv i wx i y , co pozwala na stwierdzenie uv i wx i y ∈ / L.
V1.1 – 24/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Automaty ze stosem
V1.1 – 25/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Automaty ze stosem – ogólne spojrzenie
Automaty ze stosem
Automat stosowy, analogicznie jak automat skończony ma określony skończony zbiór stanów, a także stan początkowy. Jednakże jest on dodatkowo wyposażony w stos, na który można umieszczać elementy, odczytywać element znajdujący się na wierzchu oraz zdejmować elementy. Przejścia automatu stosowego oprócz wczytywania znaków z wejścia i zmiany stanów obejmują również operacje na stosie. Automat taki może być deterministyczny lub niedeterministyczny i może zawierać ε-przejścia, tzn. po wykonaniu przejścia nie trzeba wczytywać znaku z wejścia. Istnieje też kilka rozwiązań związanych z akceptacją słowa wejściowego: akceptację wejścia sygnalizuje pusty stos, akceptacja wejścia poprzez stan akceptujący, akceptacja wejścia poprzez pusty stos i stan akceptujący.
V1.1 – 26/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Automaty ze stosem – ogólne spojrzenie
Automat stosowy – krok obliczeniowy
Automat stosowy w jednym kroku obliczeniowych wykonuje następujący zostaw czynności: 1
podgląda znak czekający na wczytanie na wejściu,
2
podgląda element na wierzchołku stosu,
3
na podstawie tych informacji wybiera jedno z przejść do wykonania,
4
jeśli to nie jest ε-przejście, to wczytywany jest jeden znak z wejścia,
5
zdejmowany jest element z wierzchołku stosu, pewna liczba określonych elementów może być włożona na stos,
6 7
zgodnie z przejściem zmieniany jest stan.
V1.1 – 27/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Automaty ze stosem – definicja formalna
Automat stosowy – definicja formalna
Automat stosowy to następująca krotka A = (Q, Σ, Γ, δ, s, ⊥), gdzie Q to skończony zbiór stanów, Σ to (skończony) alfabet wejściowy, Γ to (skończony) alfabet stosowy, δ to relacja przejścia, δ ⊆ (Q × Γ × (Σ ∪ {ε})) × (Q × Γ? ) gdzie określa się dla danego aktualnego stanu oraz znaku na wierzchołku stosu i znaku czekającego na wczytanie (lub ε jeżeli nic nie jest wczytywane), do jakiego stanu należy przejść i co należy włożyć na stos (naturalnie uprzednio należy zdjąć element z wierzchołka stosu), s ∈ Q to stan początkowy, ⊥ ∈ Γ, to symbol początkowy na stosie.
V1.1 – 28/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Automaty ze stosem – definicja formalna
Notacja automatu stosowego Automat stosowy, można zapisywać jako diagram, jednak nie jest to zbyt czytelne rozwiązanie, ze względu na operacje na stosie. Dodatkowo zapis funkcji przejścia w podstawowej wersji np.: δ = {((s, a, A), (s, AB)), ((s, a, ⊥), (s, ABC , ⊥)), . . .} również nie jest zbyt wygodny. Dlatego, będzie stosowane następująca notacja w zapisie funkcji przejścia: (s, A) →a (s, AB),
(s, ⊥) →a (s, ABC , ⊥)
Konfiguracja automatu stosowego Niech A = (Q, Σ, Γ, δ, s, ⊥) będzie zdefiniowanym automatem stosowym. Konfiguracja automatu A to dowolna trójką określona w następujący sposób: (q, α, β) ∈ Q × Σ? × Γ? gdzie q reprezentuje aktualny stan, α pozostałe do wczytania wejście, a β zawartość stosu od wierzchołka do końca stosu. Konfiguracja początkowa dla słowa x to (s, x, ⊥). V1.1 – 29/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Automaty ze stosem – definicja formalna
Krok obliczeniowy Każdy krok obliczeniowy automatu stosowego jest opisany relacją → określoną w następujący sposób: Niech A = (Q, Σ, Γ, δ, s, ⊥) będzie określonym automatem stosowym. Relacja przejścia między konfiguracjami automatu A reprezentowana przez symbol →, to najmniejsza relacja spełniająca następujące warunki: jeśli δ zawiera przejście o postaci (p, B) →a (q, γ) (gdzie naturalnie p, q ∈ Q, a ∈ Σ, B ∈ Γ, γ ∈ Γ? ), to dla dowolnego y ∈ Σ? oraz dowolnego β ∈ Γ? mamy (p, ay , Bβ) → (q, y , γβ), jeśli δ zawiera przejście o postaci (p, B) →ε (q, γ) (gdzie naturalnie p, q ∈ Q, B ∈ Γ, γ ∈ Γ? ), to dla dowolnego y ∈ Σ? oraz dowolnego β ∈ Γ? mamy (p, y , Bβ) → (q, y , γβ). Podobnie jak przy zwykłych automatach, przez →? będziemy oznaczać przechodnio-zwrotne domknięcie relacji →.
V1.1 – 30/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Automaty ze stosem – definicja formalna
Krok obliczeniowy – dwie uwagi Dwie uwagi do definicji funkcji δ: 1
Zapis (p, B) →a (q, γ) oznacza że będąc w stanie p i na wierzchołku stosu symbol B, można przejść do stanu q odczytując z wejścia a i zastępując na stosie symbol B przez słowo γ.
2
Podobnie zapis (p, B) →ε (q, γ) oznacza, iż będąc w stanie p i widząc na wierzchołku stosu symbol B można przejść do stanu q nie wczytując nic z wejścia i zastępując na stosie symbol B słowem γ.
Deterministyczny automat stosowy Automat A = (Q, Σ, Γ, δ, s, ⊥) jest automatem deterministycznym: jeśli |δ(s, a, γ)| ≤ 1, oraz q ∈ Q, a ∈ Σ ∪ {ε}, γ ∈ Γ, jeśli δ(s, ε, γ) 6= ∅ to δ(s, a, γ) = ∅ dla każdego a ∈ Σ, gdzie q ∈ Q, γ ∈ Γ.
V1.1 – 31/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Automaty ze stosem – definicja formalna
Język akceptowany przez automat
Definicja języka który jest akceptowany przez automat Niech A = (Q, Σ, Γ, δ, s, ⊥) będzie określonym automatem stosowym. Język akceptowany przez automat A jest określony następująco: L(A) = {x ∈ Σ? : ∃q∈Q (s, x, ⊥) →? (q, ε, ε)} Należy powiedzieć, iż automat stosowy akceptuje takie słowa x, dla których istnieją obliczenia prowadzące od konfiguracji początkowej (dla słowa x) do takiej konfiguracji, kiedy to całe słowo zostało wczytane, a stos jest pusty. Naturalnie, automat stosowy może być niedeterministyczny, toteż wystarczy aby istniało jedno obliczenie akceptujące, i aby słowo było akceptowane przez automat.
V1.1 – 32/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Automaty ze stosem – definicja formalna
Przykład automatu stosowego
Konstrukcja automatu akceptującego słowa zawierające tyle samo liter a oraz b. Automat będzie używać stosu w roli licznika symboli. Z każdym wczytanym a licznik zwiększa się o jedność, a z każdym wczytanym b zmniejsza się o jedność. Dodatnie wartości licznika reprezentujemy jako ⊥ i A, a ujemne, jako ⊥ i B. Dodatkowo, w momentach gdy odsłonięty jest symbol ⊥ ,to automat może zdjąć ten element ze stosu. Automat akceptuje tylko takie słowa x, gdzie po obliczeniach stos jest pusty, czyli liczba symboli a jest taka sama jak symboli b. (s, ⊥) →a (s, A) →a (s, B) →a (s, ⊥) →ε
(s, A⊥) (s, AA) (s, ε) (s, ε)
(s, ⊥) →b (s, B) →b (s, A) →b
(s, B⊥) (s, BB) (s, ε)
V1.1 – 33/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Automaty ze stosem – definicja formalna
Przykład automatu stosowego Działanie automatu dla słowa aabbba: A A A A
B
s
s
s
s
s
s
Słowo: a
a
b
b
b
a
s
s
Oczywiście taki automat może usunąć symbol ⊥, gdy nie zostało wczytane całe słowo. Jednakże takie obliczenie nie doprowadzi do zaakceptowania słowa. Należy pamiętać, że automaty stosowe są niedeterministyczne i wystarczy, aby istniało choćby jedno obliczenie akceptujące dane słowo, aby określić iż badane słowo należy do języka akceptowanego przez automat stosowy.
V1.1 – 34/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Automaty ze stosem – definicja formalna
Przykład automatu stosowego Kolejny przykład to automat akceptujący wyrażenia zbudowane z kwadratowych nawiasów [, ]. Automat funkcjonuje podobnie jak poprzedni, ale licznik przyjmuje tylko wartości dodatnie. Na stosie znajduje się element ⊥ oraz nawiasy zamykające w ilości równej aktualnej wartości licznika. Z wczytaniem każdego nawiasu otwierającego licznik jest zwiększany o jedność, a z wczytaniem każdego nawiasu zamykającego zmniejszany o jedność. (s, x) →[ (s, ]x) gdy x =], ⊥ (s, ]) →] (s, ε) (s, ⊥) →ε (s, ε) ] ]
s
]
]
]
]
]
]
]
]
]
]
s
s
s
s
s
s
s
s
s V1.1 – 35/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Równoważność gramatyk bezkontekstowych i automatów stosowych
Równoważność GBK automatów stosowych Automaty stosowe akceptują języki bezkontekstowe generowany przez gramatykę bezkontekstową: Twierdzenie Niech L będzie językiem nad alfabetem Σ. Następujące stwierdzenia są równoważne: L jest bezkontekstowy, czyli L jest generowany przez pewną gramatykę G , L = L(G ). istnieje automat stosowany A, akceptujący L, L = L(A). Dowód powyższego twierdzenia, wymaga udowodnienia trzech elementów: należy pokazać jak dla danej gramatyki bezkontekstowej skonstruować równoważny jej automat stosowy (uwaga, z jednym stanem). Następnie należy pokazać, iż konstrukcję tę można odwrócić, tzn. dla danego automatu stosowego z jednym stanem można skonstruować równoważną mu gramatykę bezkontekstową. Ostatnia część to pokazie jak zredukować liczbę stanów w automacie stosowym do jednego. V1.1 – 36/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Równoważność gramatyk bezkontekstowych i automatów stosowych
Automat stosowy i równoważna GBK Niech G będzie gramatyką bezkontekstową G = (V , T , P, S). Równoważny automat stosowy A = (Q, Σ, Γ, δ, s, ⊥), posiada tylko jeden stan Q = {s}. Na stosie automatu A przechowywane będą symbole terminalne i nieterminalne: Γ = V ∪ T . Przyjmuje się, że S = ⊥ Dla każdej produkcji X → α istnieje przejście: (s, X ) →ε (s, α) naturalnie dla a ∈ Σ istnieje przejście: (s, a) →a (s, ε). Automat A działa w następujący sposób: jeśli na wierzchołku stosu znajduje się symol terminalny, to symbol ten czeka na wejściu, zostaje wczytany i zdjęty ze stosu. Jeśli na wierzchołku stosu jest nieterminal, to należy wczytać słowo, które można z wyprowadzić z tego nieterminala. Jednakże w pierwszej kolejności należy zdecydować, jaka produkcja rozpoczyna wyprowadzenie takiego słowa. Należy dany nieterminal zdjąć ze stosu i odłożyć na stos prawą stronę wybranej produkcji dla tego nieterminala. Słowo akceptowane jest pustym stosem, w momencie gdy całe wyprowadzone słowo zostało wczytane. V1.1 – 37/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Równoważność gramatyk bezkontekstowych i automatów stosowych
Automat stosowy i równoważna GBK – przykład Gramatyka od nawiasów []: S → [S]|SS|ε Reguły automatu stosowego: (s, S) →ε (s, S) →ε (s, S) →ε (s, [) →[ (s, ]) →]
(s, [S]) (s, SS) (s, ε) (s, ε) (s, ε)
Przykład dla słowa: [[][[]]]:
V1.1 – 38/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Równoważność gramatyk bezkontekstowych i automatów stosowych
GBK równoważna danemu automatowi stosowemu z jednym stanem Założono, iż dany jest automat stosowy z jednym stanem A = ({s}, Σ, Γ, δ, s, ⊥). Można założyć, że Γ ∩ Σ = ∅. Szukana gramatyka ma postać G = (Γ, Σ, P, ⊥), przy czym jeśli funkcja przejścia δ zawiera przejście (s, B) →a (s, γ) (dla a ∈ Σ ∪ {ε}), to w zbiorze produkcji P istnieje produkcja B → aγ.
Automat stosowy akceptujący słowa zawierające tyle samo znaków a i b: (s, ⊥) →a (s, A⊥) (s, A) →a (s, AA) (s, B) →a (s, ε) (s, ⊥) →ε (s, ε) Posiada następującą GBK: S A B
(s, ⊥) →b (s, B) →b (s, A) →b
(s, B⊥) (s, BB) (s, ε)
→ aAS|bBS|ε → b|aAA → a|bBB
Wyprowadzenie słowa aabbba: S → aAS → aaAAS → aabAS → aabbS → aabbbBS → aabbbaS → aabbba V1.1 – 39/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Równoważność gramatyk bezkontekstowych i automatów stosowych
Redukcja zbioru stanów do jednego stanu
Należy wykazać, że dla automatu stosowego A = (Q, Σ, Γ, δ, s, ⊥) istnieje równoważny automat A0 = ({s}, Σ, Γ0 , δ 0 , s, ⊥). Na stosie automatu A0 znajdują się krotki o postaci (p, a, r ) ∈ Γ0 = Q × Γ × Q. Jeśli na wierzchołku stosu A0 jest trojka (p, B, r ), to odpowiada to sytuacji, gdy na wierzchołku stosu w A jest B, a A jest w stanie p i po zdjęciu symbolu B ze stosu przejdzie do stanu r . Stany znajdujące się na stosie A0 posiadają wspólny element, tzn. pod trojką (p, B, r ) musi być trojka postaci (r , C , t) (dla pewnych C ∈ Γ oraz t ∈ Q) i tak dalej. Automat A0 na początku ma na stosie krotkę (s, ⊥, q) i akceptuje słowo x wtedy i tylko wtedy, gdy A zaczynając w stanie s i z symbolem ⊥ na stosie, wczytuje x i kończy w stanie q z pustym stosem.
V1.1 – 40/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Równoważność gramatyk bezkontekstowych i automatów stosowych
Redukcja zbioru stanów do jednego stanu Relacja δ 0 jest określona następująco: jeśli δ zawiera przejście: (p, B) →a (r , B1 B2 B3 . . . Bk ) dla pewnych a ∈ Σ ∪ {ε}, p, r ∈ Q, k > 0, B, B1 B2 B3 . . . Bk ∈ Γ, to δ 0 (dla dowolnych q1 , q2 , . . . , qk ∈ Q) zawiera następujące przejścia: (s, (p, B, qk )) →a (s, (r , B1 , q1 )(q1 , B2 , q2 )(q2 , B3 , q3 ) . . . (qk−1 , Bk , qk )) jeśli δ zawiera przejście (p, B) →a (r , ε) dla pewnych a ∈ Σ ∪ {ε}, p, r ∈ Q, B ∈ Γ, to δ 0 zwiera następujące przejście: (s, (p, B, r )) →a (s, ε) Tak skonstruowany automat charakteryzuje się wysokim niedeterminizmem. Wkładając krotki na stos należy przewidzieć w jakim stanie będzie automat A w momencie zdjęcia odpowiedniej krotki w A0 . Naturalnie odgadnięcie odpowiednich stanów jest możliwe, a więc A0 będzie mógł zasymulować każde obliczenie A. V1.1 – 41/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Interpreter języka – lexer Interpreter języka programowanie na motywach tutoriala Lex & Yacc: http://epaperpress.com/lexandyacc/index.html. Elementy parsera: %{ ... %} %% /* zmienne */ [a-z] { yylval.sIndex = *yytext - ’a’; return VARIABLE; } /* liczby większe od zera */ [1-9][0-9]* { yylval.iValue = atoi(yytext); return INTEGER; } V1.1 – 42/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Interpreter języka – lexer
Interpreter języka programowanie na motywach tutoriala Lex & Yacc: http://epaperpress.com/lexandyacc/index.html. Elementy parsera: [-()<>=+*/;{}.] { return *yytext; } ">=" "<=" "==" "!=" "while" "if" "else" "print"
return return return return return return return return
GE; LE; EQ; NE; WHILE; IF; ELSE; PRINT;
V1.1 – 43/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Interpreter języka – gramatyka program: function ;
{ exit(0); }
function: function stmt | /* NULL */ ;
{ ex($2); freeNode($2); }
stmt: | | | | | | | ;
’;’ expr ’;’ PRINT expr ’;’ VARIABLE ’=’ expr ’;’ WHILE ’(’ expr ’)’ stmt IF ’(’ expr ’)’ stmt %prec IFX IF ’(’ expr ’)’ stmt ELSE stmt ’{’ stmt_list ’}’
{ { { { { { { {
$$ $$ $$ $$ $$ $$ $$ $$
= = = = = = = =
opr(’;’, 2, NULL, NULL); } $1; } opr(PRINT, 1, $2); } opr(’=’, 2, id($1), $3); } opr(WHILE, 2, $3, $5); } opr(IF, 2, $3, $5); } opr(IF, 3, $3, $5, $7); } $2; }
V1.1 – 44/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Interpreter języka – drzewo wyprowadzeń Dwa drzewa wyprowadzeń dla następującego przykładu: x = 10; while (x < 3) { print x; x = x + 1; }
= X
while ;
<
10 X
3
print X
= +
X X
1
V1.1 – 45/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
Interpreter języka – gramatyka nodeType *opr(int oper, int nops, ...) { va_list ap; nodeType *p; int i; if ((p = malloc(sizeof(nodeType))) == NULL) yyerror("brak pamięci"); if ((p->opr.op = malloc(nops * sizeof(nodeType))) == NULL) yyerror("brak pamięci"); p->type = typeOpr; p->opr.oper = oper; p->opr.nops = nops; va_start(ap, nops); for (i = 0; i < nops; i++) p->opr.op[i] = va_arg(ap, nodeType*); va_end(ap); return p; } V1.1 – 46/ 47
Wprowadzenie Postać normalna Chomsky’ego Algorytm CYK Automaty ze stosem
Interpreter języka A za tydzień na wykładzie
W następnym tygodniu między innymi
1
Algorytmy równoległe
2
Maszyna PRAM,
3
Modele pamięci
4
Twierdzenie Brenta
5
Sieci sortujące
Dziękuje za uwagę!!!
V1.1 – 47/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Algorytmy równoległe Osoba prowadząca wykład i ćwiczenia: dr inż. Marek Sawerwain Instytut Sterowania i Systemów Informatycznych Uniwersytet Zielonogórski e-mail : [email protected] tel. (praca) : 68 328 2321, pok. 328a A-2, ul. prof. Z.Szafrana 2, 65-246 Zielona Góra
Ostatnia zmiana: 2 stycznia 2013
V1.0 – 1/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Spis treści
1
Wprowadzenie Plan wykładu
2
Algorytmy równoległe Maszyna PRAM Rodzaje dostępu do pamięci Metoda dziel i zwyciężaj Symulacja CRCW za pomocą EREW Twierdzenia Brenta
3
Sieci sortujące Zasada zero-jedynkowa Bitoniczna sieć sortująca Sieć sortująca
4
A za tydzień na wykładzie
V1.0 – 2/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Plan wykładu
Plan wykładu – spotkania tydzień po tygodniu
(1) Informacje o wykładzie, poprawność algorytmów (2) Poprawność algorytmów – logika Hoarego (3) Analiza złożoności kodu wysokiego i niskiego poziomu (4) Modele algorytmiczne – maszyny proste, obwody logiczne (5) Modele algorytmiczne – maszyna Turinga oraz rachunek-λ (6) Automaty (nie)deterministyczne – część I (7) Automaty (nie)deterministyczne – część II (8) Gramatyki regularne i bezkontekstowe
V1.0 – 3/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Plan wykładu
Plan wykładu – spotkania tydzień po tygodniu
(9) Gramatyki i automaty ze stosem (10) ⇒ Algorytmy równoległe ⇐ (11) Klasy złożoności obliczeniowej (12) Pamięć logarytmiczna i wielomianowa (13) Problemy NP-zupełne (14) Wstęp do obliczeń kwantowych (15) Wybrane algorytmy kwantowe
V1.0 – 4/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Plan wykładu
Plan wykładu
1
Algorytmy równoległe 1 2 3 4 5
2
model PRAM dostęp do pamięci Fast-MAX, dziel i zwyciężaj symulacja CRCW za pomocą EREW twierdzenie Brenta
Sieci sortujące 1 2 3 4 5
komparator zasada zero-jedynkowa bitoniczna sieć sortująca siec sortująca sortowanie bitoniczne w języku C
V1.0 – 5/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Plan wykładu
Materiały wykorzystane podczas tworzenia tego wykładu, a także przydatne do dalszych studiów: 1
Ważniakowe materiały: z przedmiotu Złożoność obliczeniowa – http://wazniak.mimuw.edu.pl/,
2
Materiały o sieciach sortujących: http://www.iti.fh-flensburg. de/lang/algorithmen/sortieren/networks/indexen.htm,
3
Cormen T.H., Leiserson C.E., Rivest R.L.: Wprowadzenie do algorytmów, WNT, 1997 (starsze i nowsze wydanie), rozdział o obliczeniach równoległych,
4
Sztuka Programowania, Tom 3, Knuth Donald E., Wydawnictwa Naukowo - Techniczne, 2002.
5
Algorytmy i struktury danych, L. Banachowski, K. Diks, W. Rytter, Wydawnictwa Naukowo - Techniczne, 2006.
V1.0 – 6/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Algorytmy równoległe
Obecna technologia pozwala na stosowanie procesorów o taktowaniu około 3.5 Ghz, w przypadku typowych rozwiązań klasy PC. Jedną z możliwości wzmocnienia wydajności danego systemu obliczeniowego jest zwiększenie liczby jednostek obliczeniowych, inaczej mówiąc nad jednym problemem może pracować równolegle wiele procesorów. W efekcie od takiego rozwiązania oczekuje się iż: przyspieszenia obliczeń, zazwyczaj oczekuje się, aby czas działania był funkcją polilogarytmiczną zależną od rozmiaru wejścia, ograniczenia liczba procesorów do wielkości wielomianowej w zależności rozmiaru danych wejściowych danych.
V1.0 – 7/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Równoległe modele obliczeniowe
Najważniejsze dyskutowane obecnie modele obliczeń równoległych to min.: PRAM – równoległa maszyna RAM, sieci procesorów o ustalonej topologii połączeń (krata, hiper-sześcian, i etc.), układy logiczne. Najczęściej zakłada się, iż poszczególne procesory wykonują synchronicznie ten sam program, jednak operują na różnych danych w ramach tej samej pamięci. Dopuszcza się także sytuację że procesor może nie wykonywać żadnej czynności, ze względu na skończenie danego programu lub też ze względu na spełnienie określonych warunków, krótko mówiąc, może oczekiwać aż inne procesory również dojdą do punktu w którym dany procesor się zatrzymał.
V1.0 – 8/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Maszyna PRAM
Maszyna o dostępie swobodnym – RAM Główne elementy maszyny RAM 1
taśma wejściowa (LI ), z której odczytywane są dane wejściowe, taśma wyjściowej (LO), gdzie umieszczane są wyniki,
3
pamięć o dostępie swobodnym, poszczególne komórki są adresowane przez Ci , i = 0, 1, 2, . . ., wartość z i-tej komórki to ci albo c(i).
4
lista n instrukcji stanowiąca program, umieszczone w odrębnej przestrzeni niż RAM, Π = (π1 , π2 , . . . , πn . )
...
Licznik rozkazów
Akumulator
Program
Pamięć operacyjna
2
Lista wejściowa
Lista wyjściowa
... ...
Istnieje też licznik rozkazów, wskazujący aktualnie wykonywaną instrukcję. V1.0 – 9/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Maszyna PRAM
Instrukcje maszyny RAM Instrukcji programu Π dla RAM wchodzą min. następujące operacje: LOAD op ADD op JUMP ety
READ op SUB op JFTZ ety
STORE op MULT op JZERO ety
WRITE op DIV op HALT
gdzie op może przyjmować postać: 1
liczby całkowitej – ADD =3 ,
2
wartości adresującej pamięć RAM – MULT 3,
wartości adresującej pamięć RAM pośrednio – DIV *5. Natomiast instrukcja JUMP ety, oznacza przesunięcie licznika instrukcji do wskazanej etykiety. 3
Proste pytanie: jak zdefiniować równoległą maszynę RAM?
V1.0 – 10/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Maszyna PRAM
Równoległa maszyna RAM Ogólny schemat PRAM:
Program główny P1
P2
P3
P4
...
Pn
Wspólna pamięć operacyjna Równoległa maszyna RAM zwiera wiele procesorów pracujących synchronicznie, posiadających dostęp do wspólnej pamięci. Każdy procesor jest jest określony tak samo jak w zwykłej maszynie RAM. Procesory są ponumerowane kolejnymi liczbami naturalnymi począwszy od zera. Procesory mogą wykonywać jeden wspólny program, ale wykonanie poszczególnych instrukcji zależy od indeksu procesora. W jednym kroku obliczeniowym każdy z procesor pobiera dane z pamięci, potem wykonuje operację, którą może być wpisanie pewnych danych. Wszystkie procesory wykonują jeden krok obliczeniowy jednocześnie. V1.0 – 11/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Rodzaje dostępu do pamięci
Rodzaje dostępu do pamięci Podstawowe oznaczenia: EREW – algorytmy z wyłącznym odczytem i wyłącznym zapisem, CREW – algorytmy z jednoczesnym odczytem i wyłącznym zapisem, ERCW – algorytmy z wyłącznym odczytem i jednoczesnym zapisem, CRCW – algorytmy z jednoczesnym odczytem i jednoczesnym zapisem. Algorytmy zazwyczaj oparte są o dostęp typu EREW oraz CRCW. Istnieje także kilka sposobów rozstrzygania konfliktów zasobów: dowolny – zapamiętana jest dowolna z wartości zapisywana do tej samej komórki pamięci, priorytetowy – zapamiętywana jest wartość zapisywana przez procesor posiadający np.: najniższy (albo najwyższy) numer, mieszany – zapamiętywana wartość jest pewną, ściśle określoną kombinacją zapisywanych wartości. V1.0 – 12/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Rodzaje dostępu do pamięci
Przykłady algorytmów równoległych W przypadku dostępu CRCW dla PRAM można założyć, że procesory, które wpisują jednocześnie do tej samej komórki pamięci, to wpisują tą samą wartość. Na przykład jeśli output = 0, to wówczas następujący algorytm obliczy logiczną alternatywę w czasie stałym na maszynie CRCW PRAM: f o r e a c h 1 ≤ i ≤ n do i n p a r a l l e l i f A [ i ] = 1 t h e n o u t p u t =1; Innym przykładem dla dostępu typu CREW jest liczenie kolejnych wierszy trójkąta Pascala. Początkowo zakłada się, iż A = [0, 0, 0, 0, 0, 1]:
f o r e a c h 1 ≤ i ≤ 5 do i n A [ i ] : =A [ i ]+A [ i +1]
parallel
0 0 0 0 0 0 1
0 0 0 0 0 1 5
0 0 0 0 1 4 10
0 0 0 1 3 6 10
0 0 1 2 3 4 5
1 1 1 1 1 1 1 V1.0 – 13/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Rodzaje dostępu do pamięci
Przykłady algorytmów równoległych
Następujący algorytm oblicza pierwszą pozycję najmniejszego elementu w tablicy C [1 . . . n] w czasie O(1). f o r e a c h 1 ≤ i ≤ n do i n p a r a l l e l M[ i ] : = 0 ; f o r e a c h 1 ≤ i , j ≤ n do i n p a r a l l e l i f i 6= j and C [ i ] ≤ C [ j ] t h e n M[ i ] : = 1 ; f o r e a c h 1 ≤ i ≤ n do i n p a r a l l e l i f M[ i ] = 0 t h e n o u t p u t := i ; Algorytm korzysta z O(n2 ) procesorów.
V1.0 – 14/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Rodzaje dostępu do pamięci
Przykłady algorytmów równoległych Algorytm CRCW wskazujący pozycję pierwszej jedynki od lewej w tablicy A: f o r each 1 ≤ i f A [ i ]=1 f o r each 1 ≤ i f A [ i ]=1
i < j ≤ n do i n p a r a l l e l and A [ j ]=1 t h e n A [ j ] : = 0 ; i ≤ n do i n p a r a l l e l t h e n F i r s t O n e := i .
Algorytm korzysta z O(n2 ) procesorów, druga pętla pozwala sprawdzić obecność jedynki w tablicy: czy−j e s t −j e d y n k a : = 0 ; f o r e a c h 1 ≤ i ≤ n do i n p a r a l l e l i f A [ i ]=1 t h e n czy−j e s t −j e d y n k a : = 1 ;
V1.0 – 15/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Rodzaje dostępu do pamięci
Algorytm List-Rank Dana jest lista L o n obiektach, zadanie polega na tym iż należy policzyć odległość każdego elementu od końca listy. Zadanie to można zapisać w sposób formalny: 0, jeśli next[i] = NULL d[i] = d[next[i]] + 1, jeśli next[i] 6= NULL Przypadek sekwencyjny wymaga czasu Θ(n). Algorytm List-Rank do obliczania odległości każdego elementu od końca listy w czasie O(lg n): 1 : f o r e a c h p r o c i do i n p a r a l l e l 2: i f n e x t [ i ] = NULL t h e n 3: d [ i ] := 0 else 4: d [ i ] := 1 5 : w h i l e e x i s t s o b j e c t i s u c h t h a t n e x t [ i ] 6= NULL do 6: f o r e a c h p r o c i do i n p a r a l l e l 7: i f n e x t [ i ] 6= NULL t h e n 8: d [ i ] := d [ i ] + d [ n e x t [ i ] ] 9: n e x t [ i ] := n e x t [ n e x t [ i ] ] V1.0 – 16/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Rodzaje dostępu do pamięci
Algorytm List-Rank
(a)
(b)
(c)
(d)
3
4
6
1
0
5
1
1
1
1
1
0
3
4
6
1
0
5
2
2
2
2
1
0
3
4
6
1
0
5
4
4
3
2
1
0
3
4
6
1
0
5
5
4
3
2
1
0
V1.0 – 17/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Rodzaje dostępu do pamięci
Algorytm List-Rank – poprawność (I) Niezmiennik algorytmu List-Rank jest następujący: dla każdego obiektu i listy L na początku każdej iteracji pętli while (wiersze od 5 do 9) suma wartości d w podliście o początku w i jest równa odległości obiektu i od końca listy L np.: pod listą dla obiektu 3 jest sekwencja (3,6,0) w iteracji (b). W trakcie wykonywania algorytmu niezmiennik jest zachowywany. Ponieważ w każdym przypadku przerwania połączenia danego obiektu z następnikiem, wartość d następnika jest dodawana do wartości d tego obiektu. (II) Należy podkreślić iż dla poprawności działania algorytmu Fast-Max niezbędne są równoległe synchroniczne dostępy do pamięci. W wierszu 9 mogą być zmienione wartości kilku wskaźników next. Niezbędne jest aby wszystkie odczyty z pamięci po prawej stronie instrukcji przypisania (odczytywanie next[next[i]]) występują przed wszystkimi zapisami do pamięci (zapisy next[i]) z lewej strony instrukcji przypisania. (za Cormen T.H., Leiserson C.E., Rivest R.L.: Wprowadzenie do algorytmów, WNT, 1997 (starsze wydanie), rozdział 30 o obliczeniach równoległych)
V1.0 – 18/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Rodzaje dostępu do pamięci
Algorytm List-Rank – poprawność (III) Algorytm List-Rank jest algorytmem typu EREW. Każdy procesor jest odpowiedzialny za co najwyżej jeden odbiekt, a każdy odczyt oraz zapis w wierszach 2–7 jest wyłączny. Podobnie zapisu w wierszach 8–9. Należy podkreślić, iż zachowany jest następujący niezmiennik: dla każdych dwóch różnych obiektów k oraz l albo next[k] 6= next[l, albo next[k] = next[l] = NULL. Ten niezmiennik jest prawdziwy dla początkowej listy i pozostaje zachowany w wierszu 9. Gdyż, wszystkie wartości next nie równe NULL są różne, wszystkie odczyty w wierszu 9 są wyłączne. Należy założyć, że wykonanie wiersza 8 jest synchroniczne, jeśli wszystkie odczyty maja być wyłączne. Gdyż, wymagane jest aby wszystkie procesory i odczytały d[i], a potem d[next[i]]. Przy takiej synchronizacji, jeśli dla obiektu i wartość next[i] 6= NULL i istnieje obiekt j wskazujący na i (tzn. next[j] = i), to w pierwszym odczycie jest pobierana wartość d[i] dla procesora i, a w drugim odczycie jest pobierana wartość d[i] dla procesora j. Co potwierdza tylko, iż alg. List-Rank jest typu EREW. (za Cormen T.H., Leiserson C.E., Rivest R.L.: Wprowadzenie do algorytmów, WNT, 1997 (starsze wydanie), rozdział 30 o obliczeniach równoległych) V1.0 – 19/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Rodzaje dostępu do pamięci
Algorytm List-Rank – wydajność (I) Dla listy o n obiektach algorytm List-Rank działa w czasie O(lg n) (czas równoległy). Inicjalizacja przebiega w czasie stałym i każda iteracja pętli while zabiera stały czas. Należy pokazać, że liczba wykonywanych iteracji wynosi dokładnie dlg ne. W każdej iteracji przeskoki wskaźników powodują przekształcanie każdej listy ma dwie listy: jedną składającą się z elementów na pozycjach parzystych oraz drugiej listy o elementach na pozycjach nieparzystych. Każdy krok w którym wskaźniki przeskakują, podwaja liczbę list i zmniejsza ich długość o połowę. Toteż, po wykonaniu dlg ne iteracji wszystkie listy zawierają tylko jeden element. (II) Algorytm List-Rank wykonuje pracę Θ(n lg n), ponieważ czas działania wynosi Θ(lg n), a liczba zastosowanych procesorów jest równa Θ(n). Naiwny algorytm sekwencyjny dla problemu ustalania porządku na liście działa w czasie Θ(n), co oznacza iż alg. List-Rank wykonuje większą pracę, niż jest to konieczne, ale wielkość tej pracy została powiększona o czynnik logarytmiczny. (za Cormen T.H., Leiserson C.E., Rivest R.L.: Wprowadzenie do algorytmów, WNT, 1997 (starsze wydanie), rozdział 30 o obliczeniach równoległych) V1.0 – 20/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Rodzaje dostępu do pamięci
Algorytm Fast-Max Algorytm Fast-Max dla maszyny CRCW znajdujący maksimum w tablicy A[0 . . . n − 1]. Wykorzystuje się n2 procesorów: 01: 02: 03: 04: 05: 06: 07: 08: 09: 10:
n := L e n g t h [ A ] f o r i :=0 t o n−1 do i n p a r a l l e l m[ i ] := True f o r i :=0 t o n−1 and f o r j :=0 t o n−1 do i n i f A[ i ] < A[ j ] then m[ i ] : = F a l s e f o r i :=0 t o n−1 do i n p a r a l l e l i f m[ i ] = True t h e n max := A [ i ] r e t u r n max
parallel
Algorytm wykorzystuje n2 procesorów, każdy procesor porównuje A[i] element z A[j] elementem, gdzie 0 ≤ i, j ≤ n − 1. Powstaje macierz porównań i dlatego każdy z n2 procesor jest niejako przypisany do pewnej komórki wzmiankowanej macierzy. (za Cormen T.H., Leiserson C.E., Rivest R.L.: Wprowadzenie do algorytmów, WNT, 1997 (starsze wydanie), rozdział 30 o obliczeniach równoległych)
V1.0 – 21/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Rodzaje dostępu do pamięci
Algorytm Fast-Max Maksimum z n wartości znajdowane w czasie O(1) na maszynie CRCW algorytmem Fast-Max: 5 6 9 2 9
5 F F F T F
6 T F F T F
9 T T F T F
2 F F F F F
9 T T F T F
m F F T F T
Elementy macierz to wyniki porównania A[i] < A[j], gdzie T - True i F False. Dla każdego wiersza zawierającego wartość T Jeśli w kolumnie m w danym wierszu znajduje się wartość True, to oznacza to iż dany element jest elementem maksymalnym. (za Cormen T.H., Leiserson C.E., Rivest R.L.: Wprowadzenie do algorytmów, WNT, 1997 (starsze wydanie), rozdział 30 o obliczeniach równoległych) V1.0 – 22/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Metoda dziel i zwyciężaj
Metoda dziel i zwyciężaj W obliczeniach równoległych bardzo często stosuje się drzewa. Problem obliczenia sumy v [1] + v [2] + . . . + v [n]. Dla uproszczenia założono, że n jest potęgą dwójki i wynosi 16. rezultat
poziom 4 poziom 3 poziom 2 poziom 1
v1
v2 v3
v4 v5
v6 v7
v8 v9
v10 v11
v12 v13
v14 v15
v16
poziom 0
Wysokością węzła jest jego maksymalna odległość od liścia, a wysokość liścia wynosi 0. P-ty poziom to zbiór węzłów o wysokości p. Zakłada się, że elementy v [1], v [2], . . . , v [n] są umieszczone w liściach pełnego zrównoważonego drzewa binarnego. V1.0 – 23/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Metoda dziel i zwyciężaj
Metoda dziel i zwyciężaj Algorytm dodawania można zrealizować w następujący sposób. Pętla for wskazuje poziomy: f o r p :=1 t o log n do o b l i c z a n i e r ó w n o l e g ł e w a r t o ś c i węzłów na p−tym p o z i o m i e ;
Na poziomie p-tym poszczególne elementy odpowiadają następującym elementom v [1 · 2p ], A[2 · 2p ], . . . , A[3 · 2p ], . . . Algorytm obliczający sumę może zostać napisany w następujący sposób: f o r p :=1 t o log n do ∆ = 2p ; n f o r each 1 ≤ i ≤ ∆ do i n p a r a l l e l v [i ∗ ∆] := v [i ∗ ∆ + ∆/2] + v [i ∗ ∆] ; w y n i k := v [ n ] ; V1.0 – 24/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Metoda dziel i zwyciężaj
Ogólne spojrzenie na metodę dziel i zwyciężaj
problem P do in parallel problem P1 r1
problem P2 r2
problem Pn
... ri
rn
łączenie wyników rezultat problemu P V1.0 – 25/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Metoda dziel i zwyciężaj
Dziel i zwyciężaj – suma elementów tablicy
Sumy elementów tablicy A[1..n]. Wynik będzie rezultatem funkcji SUMA(1,n). Dla uproszczenia n jest potęgą dwójki: f u n k c j a SUMA(1, n) i f j=i t h e n return A[ i ] else do i n p a r a l l e l w y n i k 1 := SUMA(i, b(i + j)/2c) ; w y n i k 2 := SUMA(d(i + j)/2e, j) ; r e t u r n wynik1 + wynik2 ;
V1.0 – 26/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Metoda dziel i zwyciężaj
Dziel i zwyciężaj – sortowanie tablicy Niech ParallelMerge(x) będzie algorytmem, który po otrzymaniu tablicy X z posortowanymi lewą i prawą połową, da w wyniku posortowaną tablicę x. Stosunkowo łatwo to osiągnąć w czasie O(log n) z n procesorami. Dla i > n/2-ty procesor znajduje w pierwszej połówce sekwencyjnie z pomocą metodą binary search, najmniejszy element większy od X [i]. To zadanie wymaga czasu O(log n). Następnie każdy procesor wstawia element w odpowiednie miejsce. Ostatecznie otrzymuje się algorytm sortowania w czasie O(log2 ) z n procesorami. funkcja ParallelSort (x ); n:= s i z e ( x ) ; i f n>1 t h e n do i n p a r a l l e l ParallelSort ( FirstHalf (x )); P a r a l l e l S o r t ( SecondHalf ( x ) ) ; ParallelMerge (x)
V1.0 – 27/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Symulacja CRCW za pomocą EREW
Symulacja CRCW za pomocą EREW Maszyna o dostępie do pamięci typu CRCW jest lepsza o czynnik logarytmiczny od maszyny o dostępie EREW. Twierdzenie Każdy p-procesorowy algorytm typu CRCW może być co najwyżej O(lg p) razy szybszy od najszybszego p-procesorowego algorytmu EREW dla tego samego problemu. (Szkic dowodu) W symulacji jednoczesnego zapisu dla p procesorów maszyny EREW wykorzystywana jest pomocnicza tablica A o wielkości p. W przypadku, gdy procesor Pi z maszyny CRCW, dla i = 0, 1, 2, . . . , p − 1 ma zapisać wartość xi do komórki i, odpowiadający mu procesor z maszyny EREW zapisuje uporządkowaną parę (li , xi ) w A[i]. Ponieważ każdy procesor (w przypadku EREW) zapisuje w innym miejscu pamięci, zapisy te są wyłączne. Następie uzyskane pary zapisane w A są sortowane w czasie O(lg p) ze względu na pierwsze elementy w parach. Po wykonaniu sortowania wszystkie wartości, czyli drugie elementy par występują kolejno w A. V1.0 – 28/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Symulacja CRCW za pomocą EREW
Symulacja CRCW za pomocą EREW
(Szkic dowodu c.d.) Każdy procesor Pi z maszyny EREW, dla i = 1, 2, 3, . . . , p − 1, przegląda elementy A[i] = (lj , xj ) oraz A[i − 1] = (lk , xk ), gdzie wartości j oraz k spełniają warunki 0 ≤ j, k ≤ p − 1. Jeśli lj 6= lk lub i = 0, to procesor Pi , dla i = 0, 1, 2, . . . , p − 1 zapisuje wartość xj na pozycji lj w pamięci globalnej. Ponieważ tablica A została posortowana względem pierwszych elementów w parach, tylko jeden procesor zapisuje do tej samej komórki pamięci, toteż taki zapis jest wyłączny. Pozwala to stwierdzić iż można zaimplementować zapis CRCW na maszynie EREW w czasie O(lg n).
V1.0 – 29/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Symulacja CRCW za pomocą EREW
Symulacja CRCW za pomocą EREW
A
P0
0
(8,12)
P0
P0
(8,12)
0
P1
(8,12)
1
(8,12)
P1
P1
(8,12)
1
P2
(29,43)
2
(29,43)
P2
P2
(29,43)
2
P3
P3
(29,43)
3
(29,43)
P3
P3
(29,43)
3
P4
P4
(92,26)
4
(29,43)
P4
P4
(29,43)
4
P5
(8,12)
5
(92,26)
P5
P5
(92,26)
5
12
8
43
29
26
92
P5
43
26
8
A
(29,43)
P2
12
A
P0
P1
29
92
pamięć globalna
sortowanie
pamięć globalna
V1.0 – 30/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Twierdzenia Brenta
Twierdzenie Brenta Układ kombinacyjny to sieć acykliczna składająca się z elementów kombinacyjnych. Każdy taki element ma jedno lub więcej wejść. Zakłada się jednak iż zawsze będzie miał tylko jedno wyjście. Liczba wejść do stopień wejściowy, a liczba wyjść do naturalnie stopień wyjściowy. Rozmiar układu kombinacyjnego to liczba zawartych w nim elementów kombinacyjnych. Natomiast głębokością układu nazywa się najdłuższa ścieżka od wejścia układu do wyjścia układu. Twierdzenie Brenta Każdy układ kombinacyjny o rozmiarze n, głębokości d i o ograniczonym przez stałą stopniu wejściowym można symulować na maszynie CREW o p procesorach w czasie O(n/p + d).
V1.0 – 31/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Twierdzenia Brenta
Twierdzenie Brenta (Szkic dowodu) Główne ograniczenie jakie napotyka się podczas równoległej symulacji układu kombinacyjnego, to fakt iż istnieją elementy które nie mogą symulowane wcześniej, gdyż ich wejścia zależą od układów znajdujących się wcześniej. Dlatego, należy symulować wszystkie elementy na danej głębokości i, aby potem przejść na głębokości i + 1. Dla i = 1, 2, 3, . . . , n niech ni będzie liczbą elementów układu na głębokości i, co naturalnie oznacza: d X ni = n i=1
Grupując elementy ni w dni /pe grup, gdzie bni /pc pierwszych grup zawiera po p elementów, a pozostałe elementy zawarte są w ostatniej grupie, to łączny czas obliczeń można zapisać jako (na i-tej głębkości elementy można symulować równoległe w czasie O(dni /pe)): d d X X n1 n ni + 1 = + d. d e≤ p p p i=1
i=1
V1.0 – 32/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Twierdzenia Brenta
Twierdzenie Brenta ni G. 3
1
5
2
1
2
3 2
3
2
4
3
5
5
4 6
7
8
9
V1.0 – 33/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Sieci sortujące – komparator Komparator jest określony przez następującą funkcję, przyjmującą dwie wartości i zwracającą dwie wartość: x
x’ = min (x, y)
y
y’ = max (x, y)
Przykład działania komparatora: 1
1
4
1
4
4
1
4
V1.0 – 34/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Sieci sortujące – przykład Sieć sortująca o czterech wejściach i czterech wyjściach: 4
1
2
2
5
4
1
5
V1.0 – 35/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Sieci sortujące – przykład Bąbelkowa sieć sortująca lewy schemat oraz wstawiająca sieć sortująca pracy prawy schemat:
Brak równoległości w stosowaniu komparatorów. V1.0 – 36/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Sieci sortujące – przykład Sieć sortująca oparta o metodę sortowania przez wstawienie z równoległymi komparatorami:
V1.0 – 37/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Zasada zero-jedynkowa
Zasada zero-jedynkowa Zasada zero-jedynkowa, wskazuje iż jeśli sieć sortującą działa poprawnie dla wszystkich ciągów składających się zer oraz jedynek, to poprawnie sortuje wszystkie ciągi wartości zbioru liniowo uporządkowanego. Twierdzenie – zasada zero-jedynkowa Jeśli sieć porównująca o n wejściach poprawnie sortuje wszystkie 2n ciągi zer oraz jedynek, to sortuje poprawnie dowolne ciągi liczb.
W dowodzie wykorzystuje się następujący lemat: Lemat Jeśli sieć porównująca dla ciągu wejściowego a = (a1 , a2 , . . . , an ) wyznacza ciąg wyjściowy b = (b1 , b2 , . . . , bn ), to dla dowolnej funkcji niemalejącej f ta sama sieć z ciągiem f (a) = (f (a1 ), f (a2 ), . . . , f (an )) na wejściu wyznacza ciąg wyjściowy f (b) = (f (b1 ), f (b2 ), . . . , f (bn )). f(x)
min(f(x),f(y)) = f(min (x, y))
f(y)
max(f(x),f(y)) = f(max (x, y)) V1.0 – 38/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Bitoniczna sieć sortująca
Bitoniczna sieć sortująca Ciąg bitoniczny, to taki ciąg które albo posiada elementy ułożone w sposób nierosnący, a potem niemalejący, albo najpierw niemalejący, a następnie nierosnący. Ciągi (1, 4, 6, 8, 3, 2, 1) i (9, 8, 3, 2, 4, 6) to przykłady ciągów bitonicznych. W przypadku ciągów zero-jedynkowych ich postać jest następująca: 0i 1j 0k albo 1i 0j 1k , dla pewnych i, j, k ≥ 0. Ciąg niemalejący lub nierosnący także jest ciągiem bitonicznym. W bitonicznych sieciach sortujących stosuje się sieci półczyszczące: Lemat o sieci półczyszczącej Jeśli na wejście sieci półczyszczącej podany jest bitoniczny ciąg zero oraz jedynek, to ciąg wyjściowy ma następujące własności: obie połowy – górne i dolna – są bitoczniczne, każdy element w górnej połowie jest nie większy niż dowolny element w dolnej połowie oraz przynajmniej jedna połowa jest oczyszczona.
V1.0 – 39/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Bitoniczna sieć sortująca
0 0 1 1 1 0 0 0
0 0 0 0 1 0 1 1
ciąg bitoniczny oczyszczony ciąg bitoniczny
Ciąg bitoniczny
Ciąg bitoniczny
Sieć półczyszcząca
0 0 1 1 1 1 1 0
0 0 1 0 1 1 1 1
ciąg bitoniczny ciąg bitoniczny oczyszczony
V1.0 – 40/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Bitoniczna sieć sortująca
Bitoniczna sieć sortująca
bitoniczna bn/2c
sortująca sieć bitoniczna bn/2c
0 0 1 1 1 0 0 0
0 0 0 0 1 0 1 1
0 0 0 0 1 0 1 1
0 0 0 0 0 1 1 1
Ciąg posortowany
sortująca sieć
Ciąg bitoniczny
sieć półczyszcząca
Rekurencyjna definicja bitonicznej sieci sortującej:
V1.0 – 41/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Sieć sortująca
bitoniczna bn/2c
sortująca sieć bitoniczna bn/2c
0 0 1 1 0 1 1 1
0 0 1 0 1 1 1 1
0 0 1 0 1 1 1 1
0 0 0 1 1 1 1 1
Ciąg posortowany
sortująca sieć
Ciągi posortowane
Sieć scalająca
V1.0 – 42/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Sieć sortująca
Sieć sortująca Rekurencyjna definicja sieci sortującej: Merger[2] Sorter[n/2]
Merger[4] Merger[2] Merger[n/2]
Merger[8] Merger[2]
Sorter[n/2]
Merger[4] Merger[2]
1 0 1 0 1 0 0 0
0 1 0 1 0 1 0 0
0 0 1 1 0 0 0 1
0 0 0 0 0 1 1 1 V1.0 – 43/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Sieć sortująca
Złożoność obliczeniowa sieci sortujących
Złożoność podstawowych typów sieci sortujących: Sieć Liczba sekcji Liczba komparatorów Odd-even transposition sort O(n) O(n2 ) Bubblesort O(n) O(n2 ) 2 2 Bitonic sort O(log(n) ) O(n · log(n) ) 2 2 Odd-even mergesort O(log(n) ) O(n · log(n) ) 2 2 Shellsort O(log(n) ) O(n · log(n) )
V1.0 – 44/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Sieć sortująca
Sortowanie bitoniczne – wersja w języku C Uruchomienie procedury sortującej: b i t o n i c S o r t ( 0 , N, ASCENDING ) ;
Funkcja bitonicSort: v o i d b i t o n i c S o r t ( i n t s , i n t count , i n t { i f ( count > 1 ) { i n t k = count / 2;
direction )
b i t o n i c S o r t ( s , k , ASCENDING ) ; b i t o n i c S o r t ( s+k , k , DESCENDING ) ; b i t o n i c M e r g e ( s , count , d i r e c t i o n ) ; } }
V1.0 – 45/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
Sieć sortująca
Sortowanie bitoniczne – wersja w języku C void comparator ( i n t i , i n t j , i n t d i r e c t i o n ) { i f ( d i r e c t i o n == ( a [ i ] > a [ j ] ) ) i n t tmp=a [ i ] ; a [ i ]= a [ j ] ; a [ j ]=tmp ; } }
v o i d b i t o n i c M e r g e ( i n t s , i n t count , i n t i f ( count > 1) { i n t k = count / 2; i n t i ; f o r ( i=s ; i
{
direction ) {
i ++) c o m p a r a t o r ( i ,
i+k , d i r e c t i o n ) ;
bitonicMerge ( s , k , d i r e c t i o n ) ; b i t o n i c M e r g e ( s+k , k , d i r e c t i o n ) ; } } V1.0 – 46/ 47
Wprowadzenie
Algorytmy równoległe
Sieci sortujące
A za tydzień na wykładzie
W następnym tygodniu między innymi
1
złożoność obliczeniowa modelu maszyny Turinga
2
modele obliczeniowe
3
klasy złożoności obliczeniowe
4
klasy złożoności równoległej
Dziękuje za uwagę!!!
V1.0 – 47/ 47
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Klasy złożoności obliczeniowej Osoba prowadząca wykład i ćwiczenia: dr inż. Marek Sawerwain Instytut Sterowania i Systemów Informatycznych Uniwersytet Zielonogórski e-mail : [email protected] tel. (praca) : 68 328 2321, pok. 328a A-2, ul. prof. Z.Szafrana 2, 65-246 Zielona Góra
Ostatnia zmiana: 8 stycznia 2013
V1.0 – 1/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Spis treści 1
Wprowadzenie Plan wykładu
2
Klasy złożoności Maszyna Turinga – definicje Język maszyny, rekurencyjny i rekurencyjnie przeliczalny Zasoby potrzebne do obliczeń MT – czas Zasoby potrzebne do obliczeń MT – pamięć Modyfikacje maszyny Turinga
3
Klasy złożoności Klasy złożoności czasowej i pamięciowej Przyspieszenie liniowe Twierdzenie Bluma Relacje pomiędzy klasami Twierdzenie Savitcha Hierarchia czasowa i pamięciowa Zawieranie się klas złożoności
4
A za tydzień na wykładzie
V1.0 – 2/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Plan wykładu
Plan wykładu – spotkania tydzień po tygodniu
(1) Informacje o wykładzie, poprawność algorytmów (2) Poprawność algorytmów – logika Hoarego (3) Analiza złożoności kodu wysokiego i niskiego poziomu (4) Modele algorytmiczne – maszyny proste, obwody logiczne (5) Modele algorytmiczne – maszyna Turinga oraz rachunek-λ (6) Automaty (nie)deterministyczne – część I (7) Automaty (nie)deterministyczne – część II (8) Gramatyki regularne i bezkontekstowe
V1.0 – 3/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Plan wykładu
Plan wykładu – spotkania tydzień po tygodniu
(9) Gramatyki i automaty ze stosem (10) Algorytmy równoległe (11) ⇒ Klasy złożoności obliczeniowej ⇐ (12) Problemy NP-zupełne (13) Pamięć logarytmiczna i wielomianowa (14) Wstęp do obliczeń kwantowych (15) Wybrane algorytmy kwantowe
V1.0 – 4/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Plan wykładu
Plan wykładu
1
Maszyny Turinga 1 2 3
2
definicja maszyny zasoby obliczeniowe modyfikacje maszyn Turinga
Klasy złożoności obliczeniowej 1 2 3 4 5
definicja klas złożoności (czasowa, pamięciowa) przyspieszenie liniowe tw. Bluma relacje pomiędzy klasami twierdzenia o hierarchii pamięciowej i czasowej
V1.0 – 5/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Plan wykładu
Materiały wykorzystane podczas tworzenia tego wykładu, a także przydatne do dalszych studiów: 1
Cormen T.H., Leiserson C.E., Rivest R.L.: Wprowadzenie do algorytmów, WNT, 1997 (starsze i nowsze wydania),
2
Papadimitriou C.H., Złożoność obliczeniowa, Wydawnictwa Naukowo-Techniczne, Warszawa 2002. Ważniakowe materiały: http://wazniak.mimuw.edu.pl/index.php? title=Z\T1\lożoność_obliczeniowa
3
4
J.E. Hopcroft, J.D. Ullman, Wprowadzenie do teorii automatów, języków i obliczeń, Wydawnictwo Naukowe PWN, Warszawa 1994.
V1.0 – 6/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Podział na klasy złożoności – ogólne spojrzenie EXPSPACE EXPTIME PSPACE PTIME LOGSPACE LOGTIME
Twierdzenie Następujące uporządkowanie jest prawdziwe w sensie notacji O, w taki sposób iż każdy ciąg jest O od wszystkich ciągów na prawo od niego: √ √ √ √ 1, log2 n, . . . , 4 n, 3 n, n, n, n · log2 n, n n, n2 , n3 , n4 , . . . , 2n , n!, nn .
(1) V1.0 – 7/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Maszyna Turinga – definicje
Maszyna Turinga – niezbędne definicje
V1.0 – 8/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Maszyna Turinga – definicje
Maszyna Turinga – przypomnienie Formalna definicja maszyny Turinga: Maszyna Turinga M, to krotka o postaci: M = (Q, Σ, Γ, #, δ, q0 , F ), gdzie: Q to skończony zbiór stanów, Σ reprezentuje zbiór symboli wejściowych, które służą do reprezentacji wejścia maszyny i znajdują się na taśmie przed rozpoczęciem pracy maszyny, Γ to skończony zbiór symboli taśmowych - wszystkie symbole jakie mogą się znajdować na taśmie, i naturalnie Σ ⊆ Γ, # to symbol pusty - specjalny symbol taśmowy nie należący do symboli wejściowych (początkowo symbol pusty wypełnia wszystkie nie używane pola taśmy), δ – funkcja przejścia, funkcja częściowa prowadząca z Q × Γ w Q × Γ × {←, →}. Wartość δ(A, x) = (B, y , K ) oznacza, że maszyna będąca w stanie A i odczytująca symbol x z taśmy przejdzie do stanu B, po czym symbol y zostanie zapisany na taśmie a głowicę zostanie przesunięta o jedną komórkę w lewo (K =←) bądź w prawo (K =→), q0 to stan początkowy, w jakim znajduje się maszyna przed rozpoczęciem pracy, F to zbiór stanów akceptujących będący podzbiorem Q. Praca maszyny zakończy się poprawnie, kiedy osiągnięty zostanie stan ze zbioru F . V1.0 – 9/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Język maszyny, rekurencyjny i rekurencyjnie przeliczalny
Język maszyny, rekurencyjny i rekurencyjnie przeliczalny Rozpoznawanie języka Językiem maszyny M nazwiemy L(M) ⊆ Σ∗ zbiór tych słów wejściowych, dla których obliczenie maszyny M kończy się w stanie akceptującym. Inaczej mówiąc określona M rozpoznaje język L(M). Własność stopu dla maszyny Turinga: MT ma własność stopu, jeżeli dla dowolnego słowa w ∈ Σ∗ obliczenie MT na w się kończy. Język rekurencyjny Język L ⊆ Σ∗ nazywamy rekurencyjnym, lub rozstrzygalnym, jeżeli istnieje maszyna Turinga M z własnością stopu taka, że L = L(M).
V1.0 – 10/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Język maszyny, rekurencyjny i rekurencyjnie przeliczalny
Język maszyny, rekurencyjny i rekurencyjnie przeliczalny
Język rekurencyjnie przeliczalny Język L ⊆ Σ∗ nazywamy rekurencyjnie przeliczalnym (częściowo rozstrzygalnym), jeżeli istnieje taka maszyna M, że L = L(M). Pojęcie częściowej rozstrzygalność jest określane w sposób następujący, jeżeli dane słowo w jest akceptowalne, to w ∈ L o maszyna zakończy swoje działanie. W przypadku, jeśli słowo w 3 L, to obliczenia mogą się nie zakończyć.
V1.0 – 11/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Zasoby potrzebne do obliczeń MT – czas
Zasoby potrzebne do obliczeń MT – czas
Czas obliczenia maszyny M dla konkretnym słowa wejściowego w , czyli T (M, w ) to liczba kroków wykonanych, nim maszyna M zatrzyma realizację swoich obliczeń. Jeżeli M nigdy się nie zatrzyma, to mówimy, czas obliczenia jest nieskończony, co zapiszemy jako T (M, w ) = ∞. Ogólnie, czas działania maszyny M dla słów w nad alfabetem Σ: Złożoność czasowa maszyny M Funkcja f : N → N reprezentuje złożoność czasową dla maszyny M, jeśli ∀n∈N : f (n) = max{T (M, w ) : w ∈ Σn }.
V1.0 – 12/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Zasoby potrzebne do obliczeń MT – pamięć
Zasoby potrzebne do obliczeń MT – pamięć
Pamięć potrzebną do obliczenia maszyny M dla słowie w oznaczamy jako S(M, w ) definiujemy jako liczbę komórek taśmy, które zostały odwiedzone przez głowicę zanim maszyna M się zatrzyma. Jeżeli M nie zatrzymuje się dla danego w , to wartość S(M, w ) pozostaje nieokreślona. Złożoność pamięciowa maszyny M Mówimy, że funkcja f : N → N jest złożonością pamięciową maszyny M z własnością stopu, jeżeli ∀n∈N : f (n) = max{S(M, w ) : w ∈ Σn }.
V1.0 – 13/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Modyfikacje maszyny Turinga
Modyfikacja MT – maszyna k-taśmowa Innym rozszerzeniem modelu maszyny Turinga jest dodanie dodatkowych taśm. Wielotaśmowa maszyna Turinga różni się od zwykłej maszyny Turinga tym, że ma k niezależnych głowic. Głowice poruszają się po różnych taśmach, a każda taśm jest nieograniczona. W tym modelu, mechanizm sterujący podejmuje decyzje na podstawie aktualnego stanu i odczytów ze wszystkich głowic. A zapisy oraz przesunięcia głowicy na każdej z taśm są realizowane niezależnie. Dodatkowo w przeciwieństwie do zwykłych maszyn Turinga, gdzie wymagane było przesunięcie głowicy, teraz dopuszcza się aby głowice pozostawały na swoich miejscach. Formalna definicja funkcji przejścia dla k-taśmowej maszyny Turinga zależeć od stanu i odczytu ze wszystkich k taśm. Funkcja δ decyduje o zmianie stanu i wszystkich k głowic. W związku z tym ma postać: δ : Q × Γk → Q × (Γ × {←, •, →})k
Język rozpoznawany przez k-taśmową maszynę Turinga M(k) o złożoności czasowej O(f (n)) można rozpoznać przez zwykłą maszynę Turinga M o złożoności czasowej O(f (n)2 ). Dlatego, w dalszych rozważaniach nie będzie większego znaczenia, czy dana maszyna ma jedną, czy wiele taśm. V1.0 – 14/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Modyfikacje maszyny Turinga
Modyfikacja MT – maszyna niedeterministyczna
Istotną zmianą w definicji MT jest wprowadzenie niedeterminizmu do funkcji przejścia. Niedeterministyczna maszyna Turinga to taka, gdzie funkcja przejścia może przy konkretnym stanie i odczycie z taśmy może przejść do kilku różnych różnych stanów. Niedeterministyczna maszyna Turinga, to MT, gdzie funkcja przejścia jest częściową funkcją wielowartościową: δ : Q × Γ → P(Q × Γ × {←, →}) Niedeterministyczna maszyna M akceptuje słowo w , jeśli istnieje taki ciąg przejść, który kończy się stanem akceptującym. Oznacza to iż że niedeterministyczna maszyna M zatrzymuje się na słowie w , kiedy żaden z możliwych scenariuszy obliczenia nie jest nieskończony.
V1.0 – 15/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Modyfikacje maszyny Turinga
Modyfikacja MT – maszyna niedeterministyczna 0,0,R A
0,1,R 1,0,R
1,1,R
0,1,R
A 0
B
0
1
A
1,1,R
B 0
C
0
1
A
0
1
1
1
1
1
1
1
B 0
#,#,L
1
0
1
0
1
0
0
1
B
B D
1
#
B #
B 0
0
0
#
C 0
0
1
#
0
0
1
#
D
V1.0 – 16/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Modyfikacje maszyny Turinga
Modyfikacja MT – maszyna niedeterministyczna
Czas i pamięć zużytą przez niedeterministyczną maszynę Turinga M, która zatrzymuje się na słowie w określa się w następujący sposób: czas wykonania NT (M, w ) jako liczbę kroków najdłuższego z możliwych obliczeń, ilość pamięci potrzebnej do obliczenia NS(M, w ) to liczba z maksimum użytych komórek taśmy w każdym możliwym scenariuszu realizowanych obliczeń. Można pokazać, iż jeśli język L jest rozpoznawany przez niedeterministyczną maszynę Turinga w czasie O(f (n)), to istnieje deterministyczna maszyna Turinga rozpoznająca ten sam język w czasie O(c f (n) ) dla pewnej stałej c.
V1.0 – 17/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Klasy złożoności czasowej i pamięciowej
V1.0 – 18/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Klasy złożoności czasowej i pamięciowej
Klasy złożoności czasowej i pamięciowej Klasa złożoności obliczeniowej to zbiór problemów opisanych jako język spełniających określone kryterium zazwyczaj określone jako funkcja. Najbardziej podstawowe kryteria to czas i pamięć niezbędne do klasyfikacji, które zostaną określony w następujący sposób: Definicja TIME (f (n)) Poprzez TIME (f (n)) oznaczono zbiór języków L akceptowanych przez deterministyczną maszynę Turinga M o złożoności czasowej f (n). Definicja SPACE (f (n)) Poprzez SPACE (f (n)) oznaczono zbiór języków L akceptowanych przez deterministyczną maszynę Turinga M o złożoności pamięciowej f (n).
V1.0 – 19/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Klasy złożoności czasowej i pamięciowej
Klasy złożoności czasowej i pamięciowej
Klasy złożoności obliczeniowej dla maszyny niedeterministycznej są definiowane w podobny sposób: Definicja NTIME (f (n)) Poprzez NTIME (f (n)) oznaczono zbiór języków L akceptowanych przez niedeterministyczną maszynę Turinga M o złożoności czasowej f (n). Definicja NSPACE (f (n)) Poprzez NSPACE (f (n)) oznaczono zbiór języków L akceptowanych przez niedeterministyczną maszynę Turinga M o złożoności pamięciowej f (n).
V1.0 – 20/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Przyspieszenie liniowe
Przyspieszenie liniowe – za Ważniakiem Tw. o liniowym przyspieszaniu Jeśli język L jest rozpoznawany przez maszynę M o złożoności czasowej f (n) to może być rozpoznany przez maszynę M 0 o złożoności czasowej f 0 (n) = f (n) + (1 + )n, gdzie > 0. Szkic dowodu: Idea dowodu jest oparta na powiększeniu alfabetu MT, czyli zmiany wielkości „słowa” maszyny a także liczby jej stanów. Schematycznie można to przedstawić jako zamianę np.: ośmiu komórek pamięci na jedną większą w nowej maszynie. ...
1
0 1
1
0
0 1
1
... ⇒ ...
179
...
Nowa maszyna o powiększonym alfabecie rozpoczyna działanie od skompresowania słowa wejściowego na np.: drugiej taśmie i zamiany ról taśmy drugiej i wejściowej. Następnie głowica powraca na początek słowa i rozpoczyna obliczenia. V1.0 – 21/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Przyspieszenie liniowe
Przyspieszenie liniowe – za Ważniakiem Szkic dowodu cd.: W każdym kroku obliczeń M 0 odczytuje bieżącą komórkę oraz dwie sąsiednie (na wszystkich taśmach), a następnie symuluje zachowanie M w obszarze tych trzech komórek dzięki zwiększonej stosownie liczbie stanów. Jako efekt następuje modyfikacja bieżącej komórki i komórek sąsiednich oraz odpowiednie przesunięcie głowicy. Należy policzyć, czy taka symulacja rzeczywiście może okazać opłacalna. Załóżmy, że każda z komórek M 0 odpowiada c komórkom maszyny M, gdzie c - to stopień kompresji, który ostatecznie zostanie ustalony na końcu (zależy on od i M). Alfabet nowej maszyny Γ0 , to alfabet starej maszyny Γ powiększony o symbole postaci Γc , które zapewniają nam zapis c symboli M w jednym symbolu M 0 W pierwszym etapie M 0 musi dokonać kompresji, czyli odczytać c symboli i zapisać 1 symbol skompresowany. Do tego celu wystarczy jej istnienie około |Γc | dodatkowych stanów. W ostatnim skompresowanym symbolu dokładamy symbole puste dla wyrównania. Czas działania tego etapu to około n + dn/ce (odczyt związany z kompresją + powrót). V1.0 – 22/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Przyspieszenie liniowe
Przyspieszenie liniowe – za Ważniakiem Szkic dowodu cd.: W drugim etapie dokonywana jest symulacja, czyli odczytywany jest obszar trzech komórek na każdej taśmie, co zajmuje cztery kroki M 0 . Zapamiętujemy odczyt dzięki stosownemu powiększeniu liczby stanów M 0 , które wykonujemy podobnie jak przy kompresji. Tym razem nowy zbiór stanów powiększamy o około Γ3c (trzeba jeszcze pamiętać o zapamiętaniu pozycji każdej głowic wewnątrz obszarów). W tym momencie mamy pełną wiedzę kiedy maszyna M opuści obszar trzech komórek i jak zostanie on zmodyfikowany. Oczywiście jeśli w tym czasie maszyna M kończy działanie, to tak robi również M 0 . W przeciwnym wypadku obszar trzech komórek jest modyfikowany kolejnymi czterema ruchami M 0 i cykl rozpoczyna się od nowa. Wiadomo jednak, że aby M opuściła obszar trzech komórek M 0 to musi wykonać przynajmniej c ruchów. Przyspieszyliśmy zatem działanie m przynajmniej o czynnik c/8. Ostatecznie koszt czasowy to f 0 (n) = n + dn/ce + d8f (n)/ce < (1 + )n + f (n), jeśli c = d8/e, dla odpowiednio dużych n (dla małych n można stosownie rozbudować maszynę). V1.0 – 23/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Przyspieszenie liniowe
Kompresja liniowa – za Ważniakiem
Tw. o liniowej kompresji Jeśli język L jest rozpoznawany przez maszynę M o złożoności pamięciowej f (n) to może być rozpoznany przez maszynę M 0 o złożoności pamięciowej f 0 (n) = f (n), gdzie > 0. Szkic dowodu: Dowód przebiega podobnie jak przy Tw. o liniowym przyspieszeniu. Należy dokonać obliczeń dot. zużycia pamięci. Każda komórka nowej maszyny M 0 pamięta c symboli maszyny M, więc koszt pamięciowy to f 0 (n) = df (n)/ce < f (n), jeśli c = d1/e, dla odpowiednio dużych n (analogicznie jak poprzednio dla małych n można stosownie rozbudować maszynę).
V1.0 – 24/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Twierdzenie Bluma
Twierdzenie Bluma
Tw. Bluma o przyspieszeniu Jeśli istnieje język L, taki, że jeśli jest akceptowany przez maszynę Turinga o złożoności czasowej f (n), to jest również akceptowany, przez maszynę Turinga o złożoności czasowej log(f (n)). Twierdzenie to wskazuje iż nie ma najlepszego algorytmu w sensie asymptotycznym dla danego języka L. Można przyspieszyć tylko o czynnik logarytmiczny. Szczegóły dowodu można odszukać w pracy: Blum Manuel, A Machine-Independent Theory of the Complexity of Recursive Functions", Journal of the ACM Vol. 14, pp. 322-–336, 1967, doi:10.1145/321386.321395
V1.0 – 25/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Relacje pomiędzy klasami
Relacje pomiędzy klasami
Dla złożoności czasowej wyróżnia się następujące klasy złożoności: S P = j>0 TIME (nj ), klasa języków, które mogą być akceptowane w deterministycznym czasie wielomianowym, S NP = j>0 NTIME (nj ), klasa języków, które mogą być akceptowane w niedeterministycznym czasie wielomianowym, S j EXP = j>0 TIME (2n ), klasa języków, które mogą być akceptowane w deterministycznym czasie wykładniczym, S j NEXP = j>0 NTIME (2n ), klasa języków, które mogą być akceptowane w niedeterministycznym czasie wykładniczym.
V1.0 – 26/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Relacje pomiędzy klasami
Relacje pomiędzy klasami Dla złożoności pamięciowe wyróżnia się następujące klasy złożoności: L = SPACE (log n), klasa języków, które mogą być akceptowane w deterministycznej pamięci logarytmicznej, NL = NSPACE (log n), klasa języków, które mogą być akceptowane w niedeterministycznej pamięci logarytmicznej, S PSPACE = j>0 SPACE (nj ), klasa języków, które mogą być akceptowane w deterministycznej pamięci wielomianowej, S NPSPACE = j>0 NSPACE (nj ), klasa języków, które mogą być akceptowane w niedeterministycznej pamięci wielomianowej, S j EXPSPACE = j>0 SPACE (2n ), klasa języków, które mogą być akceptowane w deterministycznej pamięci wykładniczej, S j NEXPSPACE = j>0 NSPACE (2n ), klasa języków, które mogą być akceptowane w niedeterministycznej pamięci wykładniczej.
V1.0 – 27/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Relacje pomiędzy klasami
Podstawowe relacje pomiędzy poszczególnymi klasami złożoności czasowej oraz pamięciowej: TIME (f (n)) ⊆ NTIME (f (n)), każda maszyna deterministyczna jest maszyną niedeterministyczną z jednym możliwym wyborem, SPACE (f (n)) ⊆ NSPACE (f (n)), każda maszyna deterministyczna jest maszyną niedeterministyczną z jednym możliwym wyborem, TIME (f (n)) ⊆ SPACE (f (n)), gdyż określona maszyna nie może zapisać więcej komórek niż wynosi jej czas działania, NTIME (f (n)) ⊆ NSPACE (f (n)), gdyż określona maszyna nie może zapisać więcej komórek niż wynosi jej czas działania, NTIME (f (n)) ⊆ TIME (c f (n) ), na podstawie twierdzenia o symulacji maszyny niedeterministycznej na maszynie deterministycznej. Funkcja f (n) jest konstruowalna pamięciowo, gdy f (n) ≥ log n oraz istnieje deterministyczna maszyna Turinga, która mając na wejściu wartość n zapisaną w kodzie unarnym potrafi użyć dokładnie f (n) komórek pamięci po czym zatrzymuje się. V1.0 – 28/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Relacje pomiędzy klasami
Konstruowalność pamięciowa
Należy wykazać następujący fakt: Konstruowalność pamięciowa Funkcje dlogne, nk , 2n są konstruowalne pamięciowo. Szkic dowodu: Dowód konstruowalności pamięciowej funkcji dla dlog ne opiera się na implementacji klasycznego licznika binarnego. Długość zapisu liczby binarnej n to dlog ne. Dla funkcji wielomianowej należy wykonać serię prostych działań arytmetycznych polegających na mnożeniu i dodawaniu liczb naturalnych zapisanych binarnie. W przypadku funkcji wykładniczej wystarczy zaprogramować maszynę, aby n razy dokonała podwojenia liczby zużytych komórek.
V1.0 – 29/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Relacje pomiędzy klasami
Konsekwencje braku konstruowalności pamięciowej Twierdzenie o luce Istnieje funkcja rekurencyjna f(n) taka, że TIME (f (n)) = TIME (2f (n) ). Szkic dowodu:
Wykorzystana zostanie specyficzna definicja funkcji f (n), dla której każda maszyna na słowie o długości n działa w czasie co najwyżej f (n) lub działa przynajmniej 2f (n) + 1 kroków lub nie kończy działania. W ten sposób pokażemy stosowną równość klas. Rozważa się wszystkie możliwe maszyny w pewnej ustalonej kolejności M1 , M2 , . . . np. będzie to porządek leksykograficzny. Ponieważ każda maszyna może być opisana skończonym słowem, więc wygenerowanie takiego ciągu wszystkich maszyn jest możliwe. Zdefiniujmy relację binarną P(i, k) w ten sposób, by była spełniona, gdy każda maszyna od 1 do i działając na dowolnym słowie o długości i działa w czasie co najwyżej k lub działa przynajmniej 2k + 1 kroków lub nie kończy swojego działania. Tą relację jesteśmy w stanie obliczyć poprzez stosowną symulację maszyn M1 , . . . , Mi na wszystkich słowach długości i przez co najwyżej 2k + 1 kroków (oczywiście jest to dosyć czasochłonne), tym samym ewentualne brak zakończenia działania maszyn nie stanowi przeszkody. V1.0 – 30/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Relacje pomiędzy klasami
Konsekwencje braku konstruowalności pamięciowej Szkic dowodu cd:
Należy zdefiniować f (n) oraz ustalić n. Należy zauważyć, że P(n, k) musi być prawdziwe dla pewnego k. Dzieje się tak dlatego, gdyż wraz ze wzrostem k zmieniany jest zabroniony obszar czasu działania maszyn od 1 do n. Liczba testowanych słów jest jednak ograniczona - są to wszystkie słowa o długości dokładnie n dla tych maszyn. Aby P(n, k) nie było prawdą to czas działania maszyny na słowie musi trafić do obszaru zabronionego, co wobec ustalonej liczby słów i zwiększania k spowoduje, że P(n, k) w końcu będzie prawdą. Dlatego też wartość f (n) jest definiowana jako najmniejsze k. Biorąc dowolny język L ∈ TIME (2f (n) ) taki iż jest on akceptowany przez maszynę, którą oznaczono jako Mj (w sensie ustalonego porządku). Maszyna ma złożoność 2f (n) . Weźmy dowolne słowo o długości l > j, wiadomo że P(l, f (l)) jest spełnione, a tym samym maszyna Mj działa w czasie co najwyżej f (l) (bo więcej niż 2f (l) nie może z definicji klasy). Zatem L ∈ TIME (f (n)). Pomięto działanie maszyna na słowach krótszych niż j, jednakże jest to stała liczba słów, które łatwo zaakceptować w czasie rzędu ich długości lub wbudowując ich przynależność do L w daną maszynę.
V1.0 – 31/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Relacje pomiędzy klasami
Relacje pomiędzy klasami
Maszyna Turinga o złożoności pamięciowej f (n) (konstruowalnej pamięciowo) przeprowadzając obliczenie na słowie o długości n może się znaleźć w następujących konfiguracjach (będących iloczynem): liczby stanów |Q|, położeń głowic na wszystkich taśmach, jest rzędu f (n)k jednak nie mniej niż n (dokładny wynik zależy od przyjętych założeń co do wyróżnień taśmy wejściowej i wyjściowej), zawartości taśm, czyli |Γ|kf (n) . Powyższy iloczyn można ograniczyć przez c f (n) , dla pewnego c zależnego tylko od maszyny oraz korzystając z założenia, że f (n) > log n, gdyż jest konstruowalna pamięciowo.
V1.0 – 32/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Relacje pomiędzy klasami
Relacje pomiędzy klasami Zachodzi relacja: SPACE (f (n)) ⊆ TIME (c f (n) ) gdyż liczba możliwych konfiguracji maszyny o złożoności pamięciowej f (n) wynosi c f (n) , toteż maszyna, która kończy swoje działanie może zostać zasymulowana przez maszynę działającą co najwyżej tak długo jak c f (n) inaczej maszyna nie zakończy swojego działania. Zachodzi relacja: NTIME (f (n)) ⊆ SPACE (f (n)) gdyż jak już to wcześniej podana każda maszyna deterministyczna może zasymulować działanie maszyny niedeterministycznej. Wystarczy wygenerować po kolei każdy z ciągów f (n) niedeterministycznych wyborów (wykorzystując pamięciową konstruowalność). Następnie dokonujemy już deterministycznej symulacji obliczeń przez f (n) kroków.
V1.0 – 33/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Relacje pomiędzy klasami
Relacje pomiędzy klasami
Zachodzi także następująca relacja, gdyż wszystkie operacje symulacji działania maszyny niedeterministycznej można dokonać w dostępnej pamięci f (n), gdyż każdy z ciągów niedeterministycznych wyborów możemy symulować w tej samej pamięci: NSPACE (f (n)) ⊆ TIME (c f (n) ) Jak poprzednio liczba wszystkich konfiguracji wynosi c f (n) , jednak tym razem przejścia pomiędzy poszczególnymi konfiguracjami tworzą graf. Wystarczy jednak obliczyć, czy istnieje ścieżka od konfiguracji początkowej do konfiguracji końcowej, co może być obliczone w czasie wielomianowym ze względu na rozmiar grafu, a zatem w czasie asymptotycznym c f (n) .
V1.0 – 34/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Relacje pomiędzy klasami
Relacje pomiędzy klasami
Wykorzystując poprzednio określonej relacje, można udowodnić że zachodzą następujące zależności: L ⊆ NL ⊆ P ⊆ NP ⊆ PSPACE PSPACE ⊆ NPSPACE ⊆ EXP ⊆ NEXP ⊆ EXPSPACE ⊆ NEXPSPACE Nieco kłopotu sprawiają następujące relacje: NL ⊆ P, korzystamy z faktu, że NSPACE (f (n)) ⊆ TIME (c f (n) ), w tym wypadku bowiem c logn = nk , NPSPACE ⊆ EXP, również korzystamy z faktu, że k k0 NSPACE (f (n)) ⊆ TIME (c f (n) ), w tym wypadku zachodzi c n = 2n .
V1.0 – 35/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Twierdzenie Savitcha
Twierdzenie Savitcha Relacja NSPACE (f (n)) ⊆ SPACE (c f (n) ) może zostać doprecyzowana co jest główną treścią Tw. Savitcha: Twierdzenie Savitcha Jeśli f (n) jest konstruowalna pamięciowo, to NSPACE (f (n)) ⊆ SPACE (f 2 (n)). Szkic dowodu: Kluczowym elementem symulacji maszyny niedeterministycznej jest sprawdzanie czy istnieje ścieżka od konfiguracji początkowej do końcowej maszyny (problem REACHABILITY, bowiem konfigurację maszyny można potraktować jako graf). W tw. Savitch udowodnił, że problem REACHABILITY należy do SPACE (log2 n), gdzie n to rozmiar grafu. Rozmiar grafu to liczba konfiguracji, czyli c f (n) , zatem REACHABILITY wymaga czasu log2 (c f (n) ) = O(f (n))2 , co można potraktować jako tezę oraz wolno założyć iż graf ma n wierzchołków. V1.0 – 36/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Twierdzenie Savitcha
Twierdzenie Savitcha Szkic dowodu cd: Wprowadza się pomocniczą funkcję PATH(x, y , i) która ma zwrócić jedność, gdy istnieje ścieżka od x do y w grafie zawierająca co najwyżej i wierzchołków. Można również tę funkcję tę przeformułować jako PATH(b, e, n), gdzie b to stan początkowy, e końcowy, a n to maksymalna długość ścieżki w grafie konfiguracji, czyli liczba wszystkich wierzchołków. Wartość funkcji PATH(x, y , i) obliczana jest w sposób rekurencyjny. Jeśli i = 1 to sprawdzamy bezpośrednie przejście od konfiguracji x do y . W przeciwnym wypadku najpierw wybiera się dowolny wierzchołek jako kandydata na wierzchołek pośredni na ścieżce pomiędzy x i y , który oznaczmy przez t. Należy wywołać rekurencyjnie PATH(x, t, i/2) oraz PATH(t, y , i/2). Jeśli obie ścieżki istnieją to wartością funkcji jest 1, w przeciwnym wypadku testowi poddawany jest kolejny wierzchołek t. Należy w tym momencie obliczyć ilość potrzebnej pamięci. V1.0 – 37/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Twierdzenie Savitcha
Twierdzenie Savitcha Szkic dowodu cd: Głębokość rekurencji wyniesie log n, ze względu na fakt iż na każdym poziomie długość jest zmniejszana o połowę. Aby zapamiętać wywołanie rekurencyjne (stos rekurencyjny) należy zapamiętać x, y , aktualne t oraz i. Wszystkie te liczby w zapisie binarnym potrzebują log n pamięci. Razem potrzeba O(log2 n) pamięci operacyjnej. Opierając się na twierdzeniu Savitcha, można wykazać również równość pewnych klas np.: PSPACE = NPSPACE , EXPSPACE = NEXPSPACE . co oznacza iż niedeterminizm w złożoności pamięciowej dla większych funkcji nie zwiększa wydajności. Jednakże, dla klas opisujących złożoność czasową niestety nie wskazano jak dotąd takich równości.
V1.0 – 38/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Hierarchia czasowa i pamięciowa
Hierarchia pamięciowa Twierdzenie o hierarchii pamięciowej ma następującą postać: Twierdzenie o hierarchii pamięciowej Jeśli f (n) jest konstruowalna pamięciowo oraz g (n) ∈ o(f (n)), co oznacza iż g (n) rośnie asymptotycznie wolniej, to SPACE (g (n)) ( SPACE (f (n)). Szkic dowodu: Należy pokazać, że istnieje język L ∈ SPACE (f (n)) taki, że L∈ / SPACE (g (n)). Aby zapewnić pierwszy warunek, należy skonstruować maszynę M dla L, która ma złożoność pamięciową f (n). Drugi warunek można zapewnić pokazując, że żadna z maszyn o złożoności pamięciowej g (n) nie akceptuje L. Opis działania maszyny M jest następujący. Gdy na wejściu dostanie słowo o długości n, to w pierwszym etapie zostanie oznakowanych f (n) komórek pamięci na każdej z taśm. Bowiem zadanie polega na symulacji innych maszyn i należy się się upewnić, iż nie zużywają one więcej niż f (n) pamięci. V1.0 – 39/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Hierarchia czasowa i pamięciowa
Hierarchia pamięciowa Szkic dowodu cd: W drugim etapie maszyna M interpretuje słowo x z wejścia jako kod maszyny M 0 . Maszyna M odrzuca te słowa, które nie są poprawnymi kodami. Gdy kod jest poprawny, to rozpoczyna się symulacja M 0 na tym samym słowie x. Jeśli symulacja przekroczy oznakowaną pamięć f (n) to maszyna M również odrzuca słowo x. Jeśli maszyna M 0 zaakceptuje x to maszyna M odrzuca x i jeśli M 0 odrzuca x to M je akceptuje. Wykorzystuje się tu tzw. maszynę przekątniową. Maszyna M ma złożoność pamięciową f (n), więc L = L(M) ∈ SPACE (f (n)). Należy się zastanowić, czy język L należy do klasy SPACE (g (n)). Wtedy jest akceptowany przez maszynę M 0 o złożoności g (n). Należy zastanowić się co się dzieje, gdy M 0 dostanie na wejściu swój kod . Ponieważ M 0 akceptuje język w czasie g (n), więc i na słowie x działa w takim czasie. Z drugiej strony można założyć, że następuje odrzucenie x. Wtedy maszyna M zaakceptuje x, gdyż symulacja, tzn. działanie M 0 na x może zostać przeprowadzona, jako że g (n) jest asymptotycznie mniejsze niż f (n) (można pominąć przypadki dla małych n). Analogicznie, gdy M 0 akceptuje x to M je odrzuca, czyli M 0 nie może akceptować L, gdyż popełniany jest błąd na x = M 0 . Co oznacza iż otrzymuje się sprzeczność, stąd L ∈ / SPACE (g (n)). V1.0 – 40/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Hierarchia czasowa i pamięciowa
Hierarchia czasowa W analogiczny sposób można sformułować twierdzenie o hierarchii czasowej. Wprowadza się jednak dodatkowe ograniczenie na funkcję złożoności tzn. f (n) jest konstruowalna czasowo, gdy f (n) ≥ n log n oraz istnieje deterministyczna maszyna Turinga, która mając na wejściu n zapisane unarnie potrafi działać przez dokładnie f (n) kroków i zatrzymać się. Twierdzenie o hierarchii czasowej Jeśli f (n) jest konstruowalna czasowo oraz g (n) ∈ o(f (n)/ log f (n)) to TIME (g (n)) ( TIME (f (n)). Szkic dowodu: Podobnie w dowodzie twierdzenia o hierarchii pamięciowej należy skonstruujemy maszynę M, której język L = L(M) należy do TIME (f (n)), ale nie należy do TIME (g (n)). Maszyna M jest skonstruowana tak, że bierze x z wejścia i traktuje to jako kod maszyny. Następnie symuluje jej działanie jednak nie tak jak poprzednio w pamięci f (n) lecz w czasie f (n). V1.0 – 41/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Hierarchia czasowa i pamięciowa
Hierarchia czasowa Szkic dowodu cd: Aby jednak dokonać takiej symulacji maszyna M musi zliczać liczbę wykonanych kroków symulacji. Symulacja każdego kroku zajmuje log(f (n)) potrzebnych do zaimplementowania licznika. Stąd też można zasymulować każdą maszynę o złożoności asymptotycznie mniejszej niż f (n)logf (n) a tym samym wykazać przy pomocy przekątniowej metody, że język M jest różny od języka każdej z tych maszyn. I analogicznie jak w przypadku tw. o złożoności pamięciowej to samo podejście pozwala na określenie przykładowych zależności pomiędzy klasami: NTIME (n) ( PSPACE Wiedząc, że NTIME (n) ⊆ SPACE (n), to na podstawie twierdzenia o hierarchii pamięciowej SPACE (n) ( PSPACE , co kończy dowód.
V1.0 – 42/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Hierarchia czasowa i pamięciowa
Hierarchia czasowa Inny przykład: TIME (2n ) = TIME (2n+1 ) Naturalnie TIME (2n ) ⊆ TIME (2n+1 ). Biorąc dowolny język L należący do klasy TIME (2n+1 ). Istnieje zatem maszyna działająca w czasie 2n+1 . Z twierdzenia o przyspieszaniu wiadomo, że istnieje inna maszyna M 0 akceptująca ten sam język L, ale działająca w czasie 2n+1 /4, gdy zastosuje się = 1/4. Lecz z drugiej strony 2n+1 /4 = 2n /2, a zatem język L należy do TIME (2n ) co kończy uzasadnienie. Przykład wykorzystujący asymptotykę: TIME (2n ) ( TIME (22n ) Zastosujemy twierdzenie o hierarchii czasowej dla funkcji f (n) = 22n oraz g (n) = 2n . Musimy tylko wykazać, że funkcje spełniają założenia twierdzenia. Mamy jednak f (n)/log(f (n)) = 22n /2n = (2n /2n)2n zatem dominuje asymptotycznie 2n co podsumowuje dowód. V1.0 – 43/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
Zawieranie się klas złożoności
Zawieranie się klas złożoności
Kilka ważnych wniosków dot. zawierania się klas złożoności: SPACE (n1 ) ( SPACE (n2 ), gdy 0 6 1 < 2 , z własności funkcji wielomianowej, TIME (n1 ) ( TIME (n2 ), gdy 1 6 1 < 2 , jak wyżej, L ( PSPACE , gdyż logarytm rośnie wolniej niż funkcja wielomianowa, P ( EXP, korzystamy z własności, że każdy wielomian rośnie wolniej niż funkcja subwykładnicza nlogn a ta z kolei rośnie wolniej, niż każda funkcja wykładnicza, PSPACE ( EXPSPACE , podobnie jak reguła wyżej.
V1.0 – 44/ 45
Wprowadzenie
Klasy złożoności
Klasy złożoności
A za tydzień na wykładzie
W następnym tygodniu między innymi
1
redukcje i pojęcie zupełności,
2
określenie problemu NP-zupełnego,
3
przykłady problemów NP-zupełnych.
Dziękuje za uwagę!!!
V1.0 – 45/ 45
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Problemy NP-zupełne Osoba prowadząca wykład i ćwiczenia: dr inż. Marek Sawerwain Instytut Sterowania i Systemów Informatycznych Uniwersytet Zielonogórski e-mail : [email protected] tel. (praca) : 68 328 2321, pok. 328a A-2, ul. prof. Z.Szafrana 2, 65-246 Zielona Góra
Ostatnia zmiana: 15 styczeń 2013
V1.0 – 1/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Spis treści 1
Wprowadzenie Plan wykładu
2
Redukcje i zupełność Redukcje wielomianowe Redukcje logarytmiczne Transformacja wielomianowa w sensie Turinga
3
Problemy NP-zupełne Klasa NP Klasa NP – komentarz Problem SAT Pokrycie wierzchołkowe Cykl Hamiltona
4
Klasa NC Klasa NC Własności klasy NC P-zupełność
5
A za tydzień na wykładzie
V1.0 – 2/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Plan wykładu
Plan wykładu – spotkania tydzień po tygodniu
(1) Informacje o wykładzie, poprawność algorytmów (2) Poprawność algorytmów – logika Hoarego (3) Analiza złożoności kodu wysokiego i niskiego poziomu (4) Modele algorytmiczne – maszyny proste, obwody logiczne (5) Modele algorytmiczne – maszyna Turinga oraz rachunek-λ (6) Automaty (nie)deterministyczne – część I (7) Automaty (nie)deterministyczne – część II (8) Gramatyki regularne i bezkontekstowe
V1.0 – 3/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Plan wykładu
Plan wykładu – spotkania tydzień po tygodniu
(9) Gramatyki i automaty ze stosem (10) Algorytmy równoległe (11) Klasy złożoności obliczeniowej (12) ⇒ Problemy NP-zupełne ⇐
(13) Pamięć logarytmiczna i wielomianowa (14) Wstęp do obliczeń kwantowych (15) Wybrane algorytmy kwantowe
V1.0 – 4/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Plan wykładu
Plan wykładu
1
Pojęcie redukcji 1 2 3
2
Problemy NP-zupełne 1 2 3 4
3
redukcje logarytmiczne i wielomianowe transformacja wielomianowa w sensie Turinga definicja zupełności definicja klasy NP problem SAT pokrycie wierzchołkowe cykl Hamiltona
„Małe co nieco”, o klasie NC 1 2
definicja i własności klasy NC P-zupełność i jej dowodzenie
V1.0 – 5/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Plan wykładu
Materiały wykorzystane podczas tworzenia tego wykładu, a także przydatne do dalszych studiów: 1
Cormen T.H., Leiserson C.E., Rivest R.L.: Wprowadzenie do algorytmów, WNT, 1997 (starsze i nowsze wydania),
2
Papadimitriou C.H., Złożoność obliczeniowa, Wydawnictwa Naukowo-Techniczne, Warszawa 2002. Ważniakowe materiały: http://wazniak.mimuw.edu.pl/index.php? title=Z\T1\lożoność_obliczeniowa
3
4
J.E. Hopcroft, J.D. Ullman, Wprowadzenie do teorii automatów, języków i obliczeń, Wydawnictwo Naukowe PWN, Warszawa 1994.
V1.0 – 6/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Redukcje i zupełność
V1.0 – 7/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Definicja redukcji Pojęcie redukcji należy rozpocząć Niech F reprezentuje pewną rodzinę funkcji o sygnaturze {0, 1}? → {0, 1}? która domknięta na składanie i zawierającą identyczność. Redukcja Niech L1 i L2 będą językami nad alfabetem {0, 1} (języki te reprezentują zakodowane binarnie problemy decyzyjne). Problem L1 jest redukowalny do problemu L2 w sensie rodziny F co jest zapisywane jako: L1 ≤F L2 . wtedy i tylko wtedy, gdy ∃f ∈F ∀w ∈{0,1}? w ∈ L1 ⇐⇒ f (w ) ∈ L2 V1.0 – 8/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Definicja redukcji
Należy powiedzieć, że problem L1 jest w pewnym sensie co najwyżej tak trudny, jak problem L2 - pod warunkiem że znamy rozwiązanie problemu L2 oraz odpowiednią funkcję (stanowiącą redukcję), co pociąga za sobą również rozwiązanie problemu L1 . Należy zauważyć, że relacja ≤F jest preporządkiem: czyli jest to relacja zwrotna (ze względu na obecność identyczności) i przechodnia (ze względu na domkniętość rodziny F na składanie). W dalszej części będziemy wyróżniać: redukcje logarytmiczne, redukcje wielomianowe.
V1.0 – 9/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Redukcje wielomianowe
Redukcje wielomianowe
Rodzina redukcji wielomianowych (redukcje Karpa) to rodzina funkcji {0, 1}? → {0, 1}? obliczalnych na deterministycznej maszynie Turinga w czasie wielomianowym. Redukcje wielomianowe mają następującą własność: jeżeli problem L1 jest redukowalny wielomianowo do problemu L2 oraz L2 należy do klasy P, to L1 również należy do klasy P. Uzasadnienie tej własności odbywa się poprzez konstrukcję maszyny, która najpierw przekształci instancję problemu L1 do instancji problemu L2 (przekształcenie jest realizowane w czasie wielomianowym, bo L1 jest wielomianowo redukowalne do L2 ), po czym w czasie wielomianowym da odpowiedź dla instancji problemu L2 .
V1.0 – 10/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Redukcje wielomianowe
Jeden z możliwych przykładów redukowalnosci wielomianowej jest redukowalność problemu maksymalnego skojarzenia w grafie dwudzielnym do problemu maksymalnego przepływu w grafie skierowanym:
s
t
Graf dwudzielny przekształcony w sieć przepływową.
V1.0 – 11/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Redukcje wielomianowe
Ćwiczenie z redukcji wielomianowych Wiedząc, że L1 jest wielomianowo redukowalne do L2 oraz L2 należy do klasy NP. Chcemy pokazać, że L1 również należy do klasy NP. Wykorzystuje się fakt, że deterministyczna maszyna Turinga jest specjalnym przypadkiem maszyny niedeterministycznej. Wystarczy zatem najpierw uruchomić deterministyczną maszynę implementującą redukcję z L1 do L2 , po czym uruchomić niedeterministyczną maszynę, rozwiązującą problem L2 w czasie wielomianowym. Otrzymamy w tym momencie niedeterministyczną maszynę rozwiązującą problem L1 . Należy jeszcze tylko uzasadnić, dlaczego łączny czas działania tej maszyny będzie wielomianowo zależny od wielkości wejścia; wiemy jednak, że wyjście redukcji jest co najwyżej wielomianowo zależne od wielkości wejścia (maszyna ńie ma czasu"żeby zapisać więcej komórek), oraz że złożenie dwóch wielomianów nadal jest wielomianem. Własności te sprawiają, że ostateczny program będzie miał wielomianową złożoność, co oznacza że problem L1 będzie należał do klasy NP.
V1.0 – 12/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Redukcje logarytmiczne
Redukcje logarytmiczne Drugą ważną klasą redukcji jest rodzina redukcji logarytmicznych. Definiować tej rodziny wymaga modyfikacji definicji maszyny Turinga, poprzez wyznaczenie dwóch specjalnych taśm: taśmy wejściowej (tylko do odczytu) i taśmy wyjściowej. Po zapisie na taśmę wyjściową głowica przesuwa się zawsze w tym samym kierunku, co uniemożliwia odczyt poprzednio zapisanych symboli. Redukcja logarytmiczna jest funkcją obliczalną na deterministycznej maszynie Turinga z użyciem logarytmicznej ilości pamięci na taśmie roboczej. Nie są nakładane dodatkowe ograniczenia na wielkość słowa wyjściowego najczęśniej jego wielkość jest wielomianowo zależna od wielkości słowa wejściowego. Intuicyjnie transformacja logarytmiczna pozwala przechowywać na taśmie roboczej stałą liczbę wskaźników do komórek wejściowych (lub innych obiektów o podobnej wielkości).
V1.0 – 13/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Redukcje logarytmiczne
Redukcje logarytmiczne Problem maksymalnego skojarzenia w grafie dwudzielnym jest redukowalny do problemu maksymalnego przepływu w sensie rodziny transformacji logarytmicznych. Szkic dowodu: Zakłada się, że graf dwudzielny jest przedstawiony w postaci macierzy sąsiedztwa (niekoniecznie musi to być macierz kwadratowa, bo graf wejściowy jest dwudzielny) oraz że na wyjście chcemy również wypisać graf, również w postaci macierzy sąsiedztwa (tym razem będzie to macierz kwadratowa). Problem ten możemy rozwiązać, używając następujących danych na taśmie tymczasowej: dwie liczby reprezentujące pozycję aktualnie wypisywanego elementu macierzy wyjściowej (każda o rozmiarze logarytmicznie zależnym od wielkości wejścia), liczbę pamiętającą aktualną pozycję głowicy na taśmie wejściowej (rozmiar podobnie j.w.). V1.0 – 14/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Redukcje logarytmiczne
Redukcje logarytmiczne Problem maksymalnego skojarzenia w grafie dwudzielnym jest redukowalny do problemu maksymalnego przepływu w sensie rodziny transformacji logarytmicznych.
Szkic dowodu cd: Aby wypisać jakiś element macierzy wyjściowej, należy sprawdzić, jakiego typu są odpowiadające mu wierzchołki, czyli czy są one: źródłem, ujściem, elementem pierwszego zbioru czy elementem drugiego zbioru. Taka klasyfikacja może zostać wykonana z użyciem logarytmicznej ilości pamięci (polega ona na wykonaniu kilku porównań liczb o rozmiarze logarytmicznym). Jeżeli okaże się, że element macierzy reprezentuje krawędź pomiędzy rozłącznymi zbiorami grafu dwudzielnego, to należy odwołać się do grafu wejściowego. W tym celu należy obliczyć numer komórki na taśmie wejściowej, która reprezentuje interesującą nas krawędź; możemy to zrobić z użyciem tylko takiej ilości pamięci, która jest potrzebna, aby zapisać wynik. Następne zadanie to tylko przesunięcie się do odpowiedniej komórki - ta operacja nie wymaga już jednak żadnej dodatkowej pamięci. Wolno zatem stwierdzić, że przedstawiona powyżej redukcja działa z użyciem logarytmicznej ilości pamięci; problem maksymalnego skojarzenia w grafie dwudzielnym jest zatem redukowalny do problemu maksymalnego przepływu w sensie redukcji logarytmicznej. V1.0 – 15/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Transformacja wielomianowa w sensie Turinga
Transformacja wielomianowa w sensie Turinga Poniżej określona transformacje nie jest redukcją w sensie dwóch wcześniej określonych pojęć, posługuje się ona pojęciem maszyny Turinga oraz wyroczni. Maszyna Turinga z wyrocznią Maszyna z wyrocznią Q ⊆ {0, 1}? jest wielotaśmową maszyną Turinga, z jedną wyróżnioną taśmą i trzema wyróżnionymi stanami {qa , qb , qc }. Zachowanie maszyny opisuje się w następujący sposób: przejście maszyny do stanu qa jest traktowane jako odwołanie do wyroczni Q. Jeżeli słowo aktualnie zapisane na wyróżnionej taśmie należy do języka Q, to maszyna przechodzi do stanu qb ; w przeciwnym razie przechodzi do stanu qc . Odwołanie do wyroczni wliczane jest do czasu działania maszyny jako jedno przejście. Tak określona maszyna może w trakcie swojego działania wielokrotnie prosić wyrocznię o rozwiązanie problemu Q. V1.0 – 16/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Transformacja wielomianowa w sensie Turinga
Transformacja wielomianowa w sensie Turinga
Definicja transformacji: Transformacja wielomianowa w sensie Turinga Niech L1 i L2 będą językami nad alfabetem {0, 1}. Mówimy, że L1 transformuje się do L2 w sensie wielomianowej transformacji Turinga wtedy i tylko wtedy, gdy istnieje maszyna Turinga z wyrocznią L2 , rozwiązująca L1 w czasie wielomianowym. Transformacja wielomianowa w sensie Turinga może być intuicyjnie traktowana jako rodzaj podprogramów - jeżeli znamy rozwiązanie problemu L2 , to stosujemy go jako podprocedurę przy rozwiązywaniu problemu L1 .
V1.0 – 17/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Transformacja wielomianowa w sensie Turinga
Transformacja wielomianowa w sensie Turinga Nie powinno się o podprogramu traktować jako coś prostszego od całego problemu. Dość często w przypadku wielomianowego (czyli "prostego") algorytmu używający pewnego podprogramu można wskazać że pewna trudność w rozwiązywaniu danego problemu może tkwić właśnie w "trudności"tego podprogramu. Niech L1 i L2 będą językami nad alfabetem {0, 1} oraz niech L1 transformuje się do L2 w sensie transformacji wielomianowej Turinga. Poniższe dwa zdania są prawdziwe: L1 ∈ P ⇒ L2 ∈ P, L2 ∈ P ⇒ L1 ∈ P? Należy zauważyć, że transformacja z problemu L1 do L2 nie wskazuje złożoności problemu L2 . Dodatkowo, jeśli L1 ∈ P to problem ten transformuje się w sensie Turinga do każdego problemu decyzyjnego – czyli można rozwiązać L1 w ogóle nie odwołując się do wyroczni. W drugim zdaniu problem L1 można rozwiązać, stosując rozwiązanie problemu L2 jako podprogram. Złożoność czasowa tego rozwiązania będzie określona od góry przez złożenie dwóch wielomianów – czego wynikiem jest również wielomian. V1.0 – 18/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Transformacja wielomianowa w sensie Turinga
Transformacja wielomianowa w sensie Turinga
Transformacja wielomianowa w sensie Turinga wyznacza preporządek na językach zawartych w {0, 1}? , co zostanie oznaczone symbolem ≤T . Zachodzi np.: L1 ≤P L2 ⇒ L1 ≤T L2
Na maszynie z wyrocznią wykonać redukcję wielomianową (typu Karpa), po czym odwołać się do wyroczni i w zależności od jej odpowiedzi przejść do stanu akceptującego lub odrzucającego.
V1.0 – 19/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Transformacja wielomianowa w sensie Turinga
Definicja zupełności Definicja zupełności Niech C będzie pewną klasą złożoności, natomiast v preporządkiem określonym na językach zawartych w {0, 1}? (w domyśle jedną ze zdefiniowanych wcześniej rodzin transformacji). Mówimy, że problem decyzyjny L ⊆ {0, 1}? jest C-zupełny w sensie preporządku v wtedy i tylko wtedy, gdy: L ∈ C,
∀L0 ∈C L0 v L. Można powiedzieć (co jest rozumiane w prost/intuicyjnie) że problem Czupełny jest najtrudniejszym do rozwiązania problemem w klasie złożoności C. Należy zaznaczyć, że może istnieć (i zazwyczaj istnieje) więcej niż jeden problem C-zupełny. Problemy te są równoważne w sensie zastosowanej relacji preporządku v. V1.0 – 20/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Transformacja wielomianowa w sensie Turinga
Definicja zupełności i klasa P Problemami P-zupełnymi są wszystkie problemy reprezentowane przez nietrywialne języki (o języku mówi się iż jest nietrywialny, jeśli jest niepusty i różny od zbioru wszystkich słów nad danym alfabetem). Transformacja języka L1 ∈ P do nietrywialnego języka L2 ∈ P polega na rozwiązaniu problemu L1 , a następnie - w zależności od tego, czy obliczenie jest akceptujące, czy też nie - na wypisaniu jednej z dwóch ustalonych wcześniej instancji problemu L2 , z których pierwsza należy do L2 , a druga nie należy do języka L2 . P-zupełność Okazuje się iż definicja P-zupełności nie jest zbyt interesująca w kontekście transformacji w sensie Turinga, w tym przypadku ważniejsze są transformacje logarytmiczne. Jednakże problemy P-zupełne są problemami, które nie są łatwe do zrównoleglenia.
V1.0 – 21/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Problemy NP-zupełne
V1.0 – 22/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Klasa NP
Twierdzenie o klasie NP Klasa NP i problemy NP-zupełne to ważne oraz niestety nadal nierozwiązane problemy we współczesnej informatyce. Twierdzenie – klasa NP Niech L ⊆ {0, 1}? , L ∈ NP ⇐⇒ ∃p(x)−wielomian ∃L0 ∈P ∀n∈N ∀w ∈{0,1}n [w ∈ L ⇐⇒ (∃v ∈{0,1}p(n) hw , v i ∈ L0 )]. Krótkie wyjaśnienie: słowo v nazywane jest świadkiem słowa w . Wymagane jest, żeby każde słowo należące do języka L miało świadka o długości wielomianowej, natomiast żadne słowo spoza L takiego świadka nie miało. Co więcej - jest wymagane, aby sprawdzanie, czy v jest świadkiem słowa w było wykonywane w czasie wielomianowym na maszynie deterministycznej, dlatego klasę NP zwykło się nazywać klasą problemów weryfikowalnych w czasie wielomianowym.
V1.0 – 23/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Klasa NP
Szkic dowodu: W stronę ⇐ dowód jest prosty - skonstruujemy niedeterministyczną maszynę Turinga, rozwiązującą problem L. Maszyna ta najpierw przesunie głowicę za słowo wejściowe, przez następne p(n) kroków będzie wypisywać na taśmę symbole 0 lub 1 (tu jest stosowany niedeterminizm) i przesuwać głowicę w prawo. Od tego momentu maszyna będzie działać całkowicie deterministycznie – przesunie się na początek taśmy i zacznie się zachowywać jak deterministyczna maszyna rozwiązująca problem L0 w czasie wielomianowym. Jeżeli dla słowa wejściowego w istnieje świadek, to zostanie on wygenerowany przez jedną ze ścieżek postępowania w etapie niedeterministycznym. W przeciwnym przypadku wszyscy „kandydaci na świadków” zostaną odrzuceni przez maszynę rozwiązującą L0 .
V1.0 – 24/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Klasa NP
Szkic dowodu cd: Należy teraz udowodnić przejście w drugą stronę (⇒). Skoro L ∈ NP, to istnieje niedeterministyczna maszyna Turinga M rozstrzygająca problem L. Niech k oznacza maksymalny stopień rozgałęzienia maszyny M: k := max #d(s, q), (s,q)∈Σ×Q
czyli największą liczbę rozgałęzień, która może się dokonać w jednym kroku. Łatwo zauważyć, że istnieje równoważna maszyna M 0 co najwyżej (k − 1)krotnie wolniejsza (a zatem nadal wielomianowa) o maksymalnym stopniu rozgałęzienia równym 2. Co łatwo pokazać na poniższym rysunku:
1 1
2 3
2
3
4
...
...
k−1
...
V1.0 – 25/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Klasa NP
Szkic dowodu cd: Należy teraz przejść do maszyny M 0 . Jej czas działania zostanie oznaczony jako W (n); w związku z tym maszyna dla słowa wielkości n wykona co najwyżej W (n) rozgałęzień. Każda ścieżka postępowania maszyny M 0 jest zatem zdefiniowana poprzez ciąg W (n) bitów mówiących, która spośród co najwyżej dwóch dostępnych ścieżek została wybrana. Jako „kandydatów na świadków” wybierzmy zatem ciągi {0, 1}W (n) , świadkiem natomiast niech będzie ciąg reprezentujący akceptującą ścieżkę postępowania maszyny M 0 - jeśli taka istnieje. Wystarczy w tym momencie wskazać deterministyczna maszynę Turinga N, rozpoznającą język L0 – czyli weryfikującą dla pary słów hw , v i, czy v jest świadkiem dla w . Maszyna taka jest prosta do skonstruowania w następujący sposób: maszyna N najpierw przepisuje v na taśmę pomocniczą, po czym wraca na głównej taśmie do początku słowa w , maszyna N zachowuje się podobnie jak maszyna M 0 ; w przypadku, gdy maszyna ma do wyboru dwie opcje, N sięga po kolejny dostępny bit taśmy pomocniczej i na jego podstawie wybiera ścieżkę postępowania. Łatwo zauważyć, że M 0 akceptuje słowo w wtedy i tylko wtedy, gdy istnieje świadek, który spowoduje, że maszyna N dojdzie do stanu akceptującego. V1.0 – 26/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Klasa NP – komentarz
Twierdzenie o klasie NP – komentarz Przytoczone twierdzenie wskazuje , że maszyna rozwiązująca problem z klasy NP najpierw „odgaduje” świadka, a potem weryfikuje go w deterministyczny sposób w czasie wielomianowym. Trzeba jednak pamiętać, że maszyna w rzeczywistości nie źgaduje- zamiast tego sprawdza się wszystkich możliwych świadków. Tak sformułowane twierdzenie o klasie NP, pozwala na wprowadzenie następujących klas oznaczonych jako NPC , NPCL i NPCT klasy problemów NP-zupełnych w sensie odpowiednio transformacji wielomianowej Karpa, transformacji logarytmicznej i transformacji wielomianowej Turinga. Możliwe jest określenie relacji zawierania pomiędzy tymi klasami: NPCL ⊆ NPC ⊆ NPCT . Biorąc dowolny problem z NPCL , wiadomo, że można do niego przekształcić każdy problem z NP z użyciem transformacji logarytmicznej. Wiadomo także, że redukowalność logarytmiczna implikuje redukowalność wielomianową; rozpatrywany problem należy zatem do klasy NPC. Analogiczne rozumowanie można zastosować do uzasadnienia drugiej inkluzji. Niestety, nie wiadomo, czy pomiędzy jakąś parą klas zachodzi równość. V1.0 – 27/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Problem SAT
Problem SAT Kilka słów przypomnienia o logice: literałem nazywamy zmienną lub jej negację, klauzulą nazywamy alternatywę skończonej liczby literałów, formuła logiczna jest w koniunkcyjnej postaci normalnej wtedy i tylko wtedy, gdy jest koniunkcją skończonej liczby klauzul. Przykładem formuły w koniunkcyjnej postaci normalnej jest poniższa formuła: (x1 ∨ x2 ∨ ¬x3 ) ∧ (x2 ∨ x3 ) ∧ (¬x1 ∨ ¬x4 ). Formuła jest spełnialna wtedy i tylko wtedy gdy istnieje wartościowanie zmiennych, dla których ta formuła jest spełniona. Dla powyższej formuły jednym z wartościowań, dla których jest ona spełniona, jest wartościowanie przypisujące zmiennym x1 , x2 , x3 , x4 odpowiednio wartości 0, 1, 1, 0; w związku z tym powyższa formuła jest spełnialna.
V1.0 – 28/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Problem SAT
Problem SAT Niech w ∈ {0, 1}? . Wtedy w ∈ SAT reprezentuje poprawnie zakodowaną formułę logiczną w koniunkcyjnej postaci normalnej oraz formuła ta jest spelnialna. Można pokazać że problem SAT przynależy do klasy NP odnosząc się bezpośrednio do definicji klasy NP i pojęcia świadka. Co doprowadza do następującego twierdzenia: Twierdzenie Cook’a-Lewina Problem SAT jest NP-zupełny w sensie redukcji logarytmicznej. Szkic dowodu: Wiedząc, że SAT ∈ NP. Do pokazania pozostaje fakt, że ∀L∈NP L ≤L SAT . Weźmy zatem dowolny język L ∈ NP. Korzystając z udowodnionego wcześniej twierdzenia wiadomo, że istnieje p(n) - wielomian określający długość świadka - oraz wielomianowy program dla deterministycznej maszyny Turinga, weryfikujący świadka - jego czas działania to Q(n). V1.0 – 29/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Problem SAT
Problem SAT Szkic dowodu cd: Zakłada się bez straty ogólności, że program ten kontynuuje działanie po dojściu do stanu akceptującego i pozostaje w tym stanie niezależnie od symbolu pod głowicą. Jako, że wejściem programu weryfikującego jest konkatenacja słowa wejściowego i świadka, górnym ograniczeniem na czas jego działania w zależności od wielkości wejścia jest wyrażenie T (n) := Q(p(n) + n) i jest to ograniczenie wielomianowe. Główne zadanie to takie przekształcenie słowa wejściowego w w formułę logiczną, aby formuła była spełnialna wtedy i tylko wtedy, gdy w ∈ L. Szczegóły opisu postaci formuł znajdują np.: na „Ważniaku”. Ogólnie oczekuje, by w chwili początkowej na taśmie znalazło się słowo wejściowe oraz świadek, który zostanie poddany weryfikacji, Na koniec wymaga się, aby po T (n) krokach program znajdował się w stanie akceptującym (mógł się w nim znaleźć wcześniej, jednak wcześniej założono, że maszyna zatrzyma się w tym stanie, więc wystarczy, jeśli sprawdzimy w chwili T(n).
Z problemem SAT związane są poprzez redukcje problemy: 3SAT, MAXSAT. V1.0 – 30/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Pokrycie wierzchołkowe
Pokrycie wierzchołkowe Dla grafu nieskierowanego G = (V , E ) mówimy, że podzbiór V 0 ⊆ V jest pokryciem wierzchołkowym, jeśli każda krawędź w G ma co najmniej jeden z końców w zbiorze V 0 . Twierdzenie Problem pokrycia wierzchołkowego (ang. NODE COVER) jest NP-zupełny. Szkic dowodu: Dla podanego podzbioru zbioru wierzchołków bardzo łatwo sprawdzić, czy stanowi on pokrycie, zatem NODE COVER ∈ NP. Problem 3SAT można zredukować do NODE COVER. Na wejściu dla formuły φ = C1 ∧ ... ∧ Cm , zakłada się, że każda alternatywa Cj zawiera dokładnie 3 różne literały. Konstruujemy graf następujący: każde wystąpienie literału jest wierzchołkiem grafu, wystąpienia wewnątrz jednej klauzuli tworzą trójkąt. Ponadto, dla każdej pary literałów przeciwnych występujących w różnych klauzulach odpowiadające im wierzchołki łączymy krawędzią. V1.0 – 31/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Pokrycie wierzchołkowe
Pokrycie wierzchołkowe Szkic dowodu cd: Co łatwo pokazać na rysunku: (x2 ∨ ¬x3 ∨ x4 )(x1 ∨ x2 ∨ x3 )(¬x1 ∨ ¬x2 ∨ ¬x4 )(x1 ∨ ¬x2 ∨ x4 ) x4
x2
¬x4
x3
¬x3
x1
x2
¬x1
x4
¬x2
x1
¬x2
Teraz należy wykazać, że formuła wejsciowa jest spełnialna wtedy i tylko wtedy, gdy wygenerowany graf ma pokrycie wierzchołkowe o liczności k. Z ograniczenia na wielkość pokrycia wynika, że z każdego trójkąta do pokrycia muszą być wybrane dokładnie dwa wierzchołki. Jeśli formuła jest spełnialna, to w każdym trójkącie wyróżnia się jeden wierzchołek v odpowiadający literałowi równemu 1. Do pokrycia wybieramy pozostałe dwa wierzchołki. Pokrywają one wszystkie krawędzie trójkątów oraz wychodzące z tych wierzchołków krawędzie między trójkątami. Każda pozostała krawędź, wychodząca z wierzchołka v , prowadzi do pewnego wierzchołka w odpowiadającego zaprzeczeniu literału wierzchołka v , zatem literał wierzchołka w ma wartość zero i w jest wybrane do pokrycia w trójkącie, w którym występuje. Zatem krawędź (v , w ) też jest pokryta.
V1.0 – 32/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Pokrycie wierzchołkowe
Szkic dowodu cd: W drugą stronę, załóżmy, że dane jest pokrycie. W każdym trójkącie, dla wierzchołka, który nie jest w pokryciu, ustawiamy wartość odpowiedniej zmiennej tak, aby literał w tym wierzchołku był równy 1. Należy zauważyć, że takie wartościowanie jest niesprzeczne. Wynika to stąd, że przeciwne literały zawsze odpowiadają dwóm wierzchołkom z różnych trójkątów połączonych krawędzią. Co najmniej jeden z tych wierzchołków jest w pokryciu, a więc odpowiadający mu literał nie bierze udziału w obliczaniu wartościowania. Zauważmy, że tak jak i poprzednio, do realizacji redukcji wystarczy pamięć robocza rzędu n, co kończy dowód.
V1.0 – 33/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Cykl Hamiltona
Cykl Hamiltona Dla grafu nieskierowanego G = (V , E ) mówimy, że G ma cykl Hamiltona, czyli cykl przechodzący przez każdy wierzchołek dokładnie raz. Twierdzenie CYKL HAMILTONA jest NP-zupełny. Szkic dowodu: Przynależność do klasy NP jest łatwa (względnie) do udowodnienia. Należy zająć się konstrukcją redukcji z problemu NODE COVER. Na wejściu mamy nieskierowany graf G = (V , E ) oraz liczbę całkowitą k ≤ |V |. Oznaczmy graf wynikowy jako G 0 = (V 0 , E 0 ). Redukcja przeprowadzona jest techniką gadżetu (stosuje się również termin widget). Gadżet to fragment struktury wynikowej o określonych własnościach. W naszym przypadku pierwszym krokiem redukcji jest wygenerowanie, dla każdej krawędzi (u, v ) ∈ E , gadżetu Guv = (Vuv , Euv ) będącego grafem przedstawionym na rysunku pokazanym dalej. V1.0 – 34/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Cykl Hamiltona
Cykl Hamiltona Szkic dowodu cd: [u, v, 1]
[v, u, 1]
[u, v, 2]
[v, u, 2]
[u, v, 3]
[v, u, 3]
[u, v, 4]
[v, u, 4]
[u, v, 5]
[v, u, 5]
[u, v, 6]
[v, u, 6]
Guv
Jedynie narożne wierzchołki grafu Guv będą połączone z wierzchołkami spoza Guv . Stąd wynika, że jeśli G 0 ma cykl Hamiltona, to musi on przechodzić przez Guv tylko na jeden z przedstawionych na rysunku sposobów. Konstrukcja gadżetu uniemożliwia inne usytuowanie cyklu Hamiltona względem Guv niż pokazane na rysunku na następnym slajdzie.
V1.0 – 35/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Cykl Hamiltona
Cykl Hamiltona Szkic dowodu cd:
Drugi krok redukcji to wygenerowanie krawędzi w G 0 łączących gadżety w tak zwane ścieżki. Dla każdego wierzchołka v ∈ V najpierw porządkujemy dowolnie wszystkie jego sąsiednie wierzchołki, oznaczmy je przez d(v ) uv1 , . . . , uv , gdzie d(v ) jest stopniem wierzchołka v . Konstrukcja ścieżki odpowiadającej wierzchołkowi v , łączącej wszystkie gadżety odpowiadające krawędziom incydentnym z v , dokonuje się przez dołączenie do G 0 zbioru krawędzi postaci Ev = {([v , uvi , 6], [v , uvi+1 , 1]), i = 1, . . . , d(v ) − 1}. V1.0 – 36/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Cykl Hamiltona
Cykl Hamiltona
Szkic dowodu cd: Ostatni krok to dodanie wierzchołków-selektorów s1 , . . . , sk , i połączenie krawędzią każdego selektora z początkiem i końcem ścieżki odpowiadającej wierzchołkowi v, dla każdego v. ES = {(si , [v , uv1 , 1]) : v ∈ V , 1 ≤ i ≤ k}{(si , [v , uvd (v ), 6]) : v ∈ V , 1 ≤ i ≤ k Definicja odpowiednich wierzchołków i krawędzi to: [ [ [ V0 = Vuv ∪ {sj , 1 ≤ j ≤ k}, E 0 = Euv ∪ Ev ∪ ES . (uv )∈E
(uv )∈E
v ∈V
V1.0 – 37/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Cykl Hamiltona
Cykl Hamiltona Szkic dowodu cd: u
w
y
x
Gux
Gwx
Gwy
Gxy
s1 s2
Na rysunku pokazano graf o 4 wierzchołkach i rezultat redukcji. Pogrubione krawędzie tworzą cykl Hamiltona. Zaczynając od selektora s1 , przechodzi się do początku ścieżki odpowiadającej pierwszemu wierzchołkowi z pokrycia, czyli x. Po przejściu gadżetów na tej ścieżce wracamy do s2 , a stąd do początku ścieżki odpowiadającej drugiemu węzłowi z pokrycia, y . V1.0 – 38/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Cykl Hamiltona
Cykl Hamiltona Szkic dowodu cd: Należy teraz wykazać, że G 0 ma cykl Hamiltona wtedy i tylko wtedy, gdy G ma pokrycie o liczności k. Zakłada się, że G 0 ma cykl Hamiltona i należy prześledzić jego bieg, zaczynając od s1 . Następny wierzchołek na cyklu musi być początkiem (lub końcem - załóżmy to pierwsze) ścieżki gadżetów dla pewnego wierzchołka v1 ∈ V . Dodajemy v1 do generowanego pokrycia. Zgodnie z własnością gadżetu, cykl przebiega całą ścieżkę i na końcu przechodzi do innego selektora, załóżmy, że jest to s2 . Z s2 musi przejść na początek lub koniec innej ścieżki, odpowiadającej wierzchołkowi v2 . Dodajemy v2 do pokrycia i kontynuujemy. Z ostatniej, k-tej ścieżki, cykl musi wrócić do s1 . Ponieważ cykl Hamiltona przeszedł przez wszystkie wierzchołki G 0 , a więc przez wszystkie gadżety Guv , zatem wybrane w ten sposób wierzchołki v1 , . . . , vk stanowią pokrycie.
V1.0 – 39/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Cykl Hamiltona
Cykl Hamiltona
Szkic dowodu cd: Teraz należy założyć, że G ma pokrycie {v1 , ..., vk }. Konstruujemy cykl Hamiltona w G 0 . Zaczynamy od selektora s1 i przechodzimy na początek ścieżki związanej z v1 , czyli do węzła [v1 , uv11 , 1]. Przechodzimy przez kolejne gadżety aż do końca ścieżki. Dla danego gadżetu Gv1 uvi musimy podjąć decyzję, czy przechodzimy przez wszystkie wierz1 chołki, czy tylko przez połowę (jedną "ścianę"). Decyzja zależy od tego, czy uvi 1 również należy do pokrycia. Jeśli nie, to przechodzimy cały gadżet; jeśli tak, to drugą "ścianę"pozostawiamy, aby później, gdy trawersowana będzie ścieżka dla uvi 1 również można było przejść przez Gv1 uvi . Z ostatniego wę1 zła na ścieżce przechodzimy do selektora s2 i powtarzamy konstrukcję. Z ostatniego węzła na k-tej ścieżce wracamy do s1 , zamykając w ten sposób cykl Hamiltona.
V1.0 – 40/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Cykl Hamiltona
Cykl Hamiltona Szkic dowodu cd: u
w
y
x
Gux
Gwx
Gwy
Gxy
s1 s2
Ostatnim krokiem dowodu jest stwierdzenie, że konstrukcję grafu G 0 można wykonać, posługując się pamięcią roboczą rozmiaru logarytmicznego. Wynika to, jak i w poprzednich dowodach, z tego że maszynie wystarcza pamięć na licznik położenia w wejściowym grafie oraz licznik numeru (nazwy) generowanego wierzchołka i krawędzi grafu G 0 .
V1.0 – 41/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Cykl Hamiltona
Rodzina problemów NP-zupełnych
Ze względu na przechodniość redukcji, można wskazać następujące redukcje przykładowych problemów NP-zupełnych:
CLIQUE VERTEX-COVER SAT
CNF-SAT
3SAT
HAMPATH
UHAMPATH
SUBSET-SUM
V1.0 – 42/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Problemy P-zupełne i klasa NC
V1.0 – 43/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Klasa NC
Klasa NC O algorytmie równoległym mówi się iż jest efektywny, jeśli działa w czasie polilogarytmicznym, na wielomianowej liczbie procesorów. Toteż o danym problemie mówi się, iż można go efektywnie zrównoleglić, jeśli ten problem posiada efektywny algorytm równoległy Klasa NC – klasa Nicka Dla n ≥ 1 klasa N i to zbiór języków L takich, że L jest akceptowany przez jednostajną rodzinę układów logicznych rozmiaru wielomianowego i[ głębokości O(logi n). Przyjmuje się następujące oznaczenie NC = NC i . j>0
Zachodzą dwie poniższe relacje: NC 1 ⊆ L oraz NL ⊆ NC 2 .
V1.0 – 44/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Własności klasy NC
Własności klasy NC Twierdzenie NC ⊆ P
Zachodzi następująca relacja: NC ⊆ P. Szkic dowodu: Dla zadanego języka L ∈ NC i należy najpierw wygenerować obwód Wi , co można zrobić w pamięci logarytmicznej, co pociąga za sobą czas wielomianowym. Następnie wykonuje się symulację obwodu, rozpatrując jego bramki w porządku topologicznym. Bramek jest wielomianowa liczba należy też pod uwagę wziąć głębokość obwodu – Twierdzenie Brenta. Sposób dostępu do pamięci wpływa na postać hierarchii złożoności w klasie NC: EREW (exclusive read/write): algorytmy, w których równoczesny dostęp do tej samej komórki pamięci nie jest dopuszczalny, CREW (concurrent read, exclusive write): dopuszczalny jest równoczesny odczyt z tej samej komórki, CRCW (concurrent read/write): dopuszczalny równoczesny odczyt oraz równoczesny zapis ale z synchroniczności modelu PRAM wynika, że nie jest możliwe, równoczesne czytanie oraz zapisywanie w tym samym czasie do tej samej komórki. V1.0 – 45/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
Własności klasy NC
Własności klasy NC Niech EREW k oznacza zbiór języków akceptowanych przez maszynę EREW o wielomianowej liczbie procesorów i złożoności czasowej O(logk n). Analogiczne oznaczenia zostają wprowadzone dla modeli CREW i CRCW. Dodatkowo przez AC oznacza się wariant jednostajnych obwodów logicznych, w którym pominięto ograniczenie na stopień wejściowy bramki. Na przykład, alternatywa k bitów może być obliczana obwodem o głębokości 1. Klasa AC j to z definicji klasa języków akceptowanych przez takie obwody, o głębokości O(log j n). Należałoby też pokazać NC j ⊆ EREW j , oraz że AC j ⊆ NC j+1 , j = 0, 1, . . .. Ważna i trudniejsza do udowodnienia jest trzecia własność: CRCW (log j n) = AC j . Z powyższych uwag otrzymuje się hierarchię klas złożoności równoległej. Dla wartości j = 1, 2, 3, . . .: NC j ⊆ EREW j ⊆ CREW j ⊆ CRCW j ⊆ AC j ⊆ NC j+1 . V1.0 – 46/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
P-zupełność
P-zupełność Definicja problemu P-zupełnego jest następująca: Definicja P-zupełności Język L ⊆ {0, 1}∗ jest P-zupełny, jeśli L ∈ P oraz dla każdego języka L0 ∈ P istnieje redukcja logarytmiczna L0 ≤L L. Redukcja logarytmiczna zachowuje złożoność równoległa, a związek pomiędzy redukcją logarytmiczną a przynależnością do klasy NC jest wyrażony w następujący sposób: Twierdzenie Jeśli Q1 ≤L Q2 oraz Q2 ∈ NC j , j ≥ 2, to Q1 ∈ NC j . Szkic dowodu: Wystarczy zauważyć że złożenie dwóch algorytmów klasy NC j jest algorytmem klasy NC j . W tym momencie wystarczy skorzystać z faktu, że NL ⊆ NC 2 . V1.0 – 47/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
P-zupełność
Dowodzenie P-zupełności Aby dowieść, że dany problem p jest P-zupełny, należy: wykazać, że p ∈ P,
wybrać P-zupełny problem Q i zredukować go logarytmicznie do p. Wartościowanie obwodu logicznego (ang. circuit value) jest zazwyczaj podstawowym problemem P-zupełnym. Twierdzenie Problem CIRCUIT VALUE jest P-zupełny. Szkic dowodu: Dany jest język L ∈ P i deterministyczna MT oznaczona przez M rozpoznająca L w czasie wielomianowym. Należy skonstruować maszynę Turinga M 0 , która dla zadanego słowa w ∈ {0, 1}∗ wygeneruje obwód C (w ) z ustalonymi wartościami bramek wejściowych taki, że M akceptuje w wtedy i tylko wtedy, gdy C (w ) = 1.
V1.0 – 48/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
P-zupełność
Dowodzenie P-zupełności
Szkic dowodu cd: Należy wykorzystać redukcję maszyny Turinga do obwodu logicznego,. Redukcja ta pokazuje, że maszyna Turinga działająca w czasie T (n) może być symulowana przez obwód logiczny o O(T 2 (n)) bramkach. Jednakże, należy wykazać, że obwód symulujący maszynę może być skonstruowany przez algorytm o logarytmicznej złożoności pamięciowej. Co znajduje potwierdzenie, że dla ustalonej M podukłady stosowane w redukcji są tej samej ustalonej postaci. Algorytm redukcji musi je wyprodukować w odpowiedniej ilości i połączyć w sieć, jednak to tej operacji wystarcza zliczaniem, czyli operacje na indeksach. W efekcie oznacza to problem wartościowania jest P-zupełny.
V1.0 – 49/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
P-zupełność
Dowodzenie P-zupełności Można również wykazać, że problem MONOTONE CIRCUIT VALUE gdzie nie dopuszcza się stosowania w obwodzie bramek negacji, również jest P-zupełny. Szkic dowodu: Należy zredukować problem CIRCUIT VALUE do MONOTONE C.V. Za pomocą praw de Morgana można nie jako przesunąć wszystkie negacje w dół, aż do bramek wejściowych. Następnie bramki wejściowe, których następnikami są negacje, zamienić na przeciwne, dodając nowe, jeśli trzeba - gdy bramka wejściowa jest poprzednikiem dwóch bramek, przy czym dokładnie jedna z tych dwóch jest negacją. Zadanie to można zrealizować w pamięci logarytmicznej, bo wystarcza przeglądać listę bramek (dla każdej podane jest jej sąsiedztwo), a nie badać całej struktury obwodu jako grafu. Inny ważnym przykładem jest problem znajdowania maksymalnego przepływu, który jest P-zupełny i jest trudny zagadnieniem do zrównoleglenia (nie istnieją jak dotąd w pełni efektywne rozwiązania). V1.0 – 50/ 51
Wprowadzenie
Redukcje i zupełność
Problemy NP-zupełne
Klasa NC
A za tydzień na wykładzie
W następnym tygodniu między innymi
1
dopełniania klas
2
pamięć logarytmiczna, wielomianowa
3
klasy L,NL,coNL, cpNP, DP
4
hierarchia wielomianowa
5
maszyna alternująca
6
złożoność wykładnicza
Dziękuje za uwagę!!!
V1.0 – 51/ 51
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Pamięć logarytmiczna i wielomianowa Osoba prowadząca wykład i ćwiczenia: dr inż. Marek Sawerwain Instytut Sterowania i Systemów Informatycznych Uniwersytet Zielonogórski e-mail : [email protected] tel. (praca) : 68 328 2321, pok. 328a A-2, ul. prof. Z.Szafrana 2, 65-246 Zielona Góra
Ostatnia zmiana: 17 stycznia 2013
V1.0 – 1/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Spis treści 1
Wprowadzenie Plan wykładu
2
Dopełnienia klas Dopełnienia klas
3
PLiHW Klasy L, NL i coNL Problem osiągalności Klasa coNP i DP Maszyny Alternujące Hierarchia wielomianowa
4
PWiZW Klasa PSPACE Klasa PSPACE – problemy zupełne Złożoność wykładnicza P = NP ⇒ EXP = NEXP Wyrażenia regularne
5
A za tydzień na wykładzie
V1.0 – 2/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Plan wykładu
Plan wykładu – spotkania tydzień po tygodniu
(1) Informacje o wykładzie, poprawność algorytmów (2) Poprawność algorytmów – logika Hoarego (3) Analiza złożoności kodu wysokiego i niskiego poziomu (4) Modele algorytmiczne – maszyny proste, obwody logiczne (5) Modele algorytmiczne – maszyna Turinga oraz rachunek-λ (6) Automaty (nie)deterministyczne – część I (7) Automaty (nie)deterministyczne – część II (8) Gramatyki regularne i bezkontekstowe
V1.0 – 3/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Plan wykładu
Plan wykładu – spotkania tydzień po tygodniu
(9) Gramatyki i automaty ze stosem (10) Algorytmy równoległe (11) Klasy złożoności obliczeniowej (12) Problemy NP-zupełne (13) ⇒ Pamięć logarytmiczna i wielomianowa ⇐ (14) Wstęp do obliczeń kwantowych (15) Wybrane algorytmy kwantowe
V1.0 – 4/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Plan wykładu
Plan wykładu
1 2
Dopełniania klas Pamięć logarytmiczna i hierarchia wielomianowa 1 2 3 4 5 6
3
klasy L, NL, coNL, problem osiągalności Twierdzenie Immermana-Szelepcsényi’ego klasy NP, coNP, DP maszyna Alternująca Hierarchia wielomianowa
Pamięć wielomianowa i złożoność wykładnicza 1 2 3 4
klasa PSPACE i zupełność problem Geography złożoność wykładnicza wyrażenia regularne – „mały horror złożoności obliczeniowej”.
V1.0 – 5/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Plan wykładu
Materiały wykorzystane podczas tworzenia tego wykładu, a także przydatne do dalszych studiów: 1
Cormen T.H., Leiserson C.E., Rivest R.L.: Wprowadzenie do algorytmów, WNT, 1997 (starsze i nowsze wydania),
2
Papadimitriou C.H., Złożoność obliczeniowa, Wydawnictwa Naukowo-Techniczne, Warszawa 2002. Ważniakowe materiały: http://wazniak.mimuw.edu.pl/index.php? title=Z\T1\lożoność_obliczeniowa
3
4
J.E. Hopcroft, J.D. Ullman, Wprowadzenie do teorii automatów, języków i obliczeń, Wydawnictwo Naukowe PWN, Warszawa 1994.
V1.0 – 6/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Dopełnienia klas
V1.0 – 7/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Dopełnienia klas
Dopełnienia klas P∗ \L oznaczamy jego dopełnienie. W Jeśli L jest językiem to przez L = przypadku problemów decyzyjnych dopełnienie (ang. COMPLEMENT) to problem decyzyjny, w którym odpowiedzi są odwrócone. Jeśli rozważymy problem SAT, w którym pytamy czy formuła może zostać spełniona, to jego dopełnienie to SAT COMPLEMENT. Jest to problem bardzo blisko spokrewniony z TAUTOLOGY, w którym pytamy czy każde wartościowanie formuły φ ją spełnia. SAT COMPLEMENT to pytanie, czy formuła nie ma wartościowań spełniających, co jest równoważne temu, że ¬φ jest formułą zawsze spełnioną, czyli jest tautologią. Jednak należy zwrócić uwagę iż COMPLEMENT nie jest ściśle dopełnieniem języka, gdyż np.: SAT zawiera także wszystkie słowa, które nie są poprawnymi opisami formuł. Takie słowa naturalnie nie stanowią jednak problemu w rozpoznawaniu.
V1.0 – 8/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Dopełnienia klas
Dopełnienia klas Definicja pojęcia dopełnienia klasy złożoności wymaga przypomnienia, że klasy złożoności składają się z języków. Jeśli C jest dowolną klasą złożoności to przez coC oznaczono jej dopełnienie, które jest złożone z dopełnień języków z klasy C . Łatwo zauważyć, że jeśli C jest klasą deterministyczną, to coC = C ze względu na fakt, iż maszyna deterministyczna, która akceptuje język L ∈ C po zamianie rolami stanu akceptującego i odrzucającego stanie się maszyną akceptującą język L. Wiadomo tez iż klasy niedeterministycznej złożoności pamięciowej są zamknięte na dopełnienia, natomiast w przypadku klas niedeterministycznych złożoności czasowej nie wiemy jakie są relacje pomiędzy nimi i jest to problem otwarty.
V1.0 – 9/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Pamięć logarytmiczna i hierarchia wielomianowa
V1.0 – 10/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Klasy L, NL i coNL
Klasy L, NL i coNL
Poniższe klasy mogą używać tylko logarytmiczną ilość pamięci operacyjnej: klasa L = SPACE (log n), to klasa tych języków, które mogą być akceptowane w deterministycznej pamięci logarytmicznej, klasa NL = NSPACE (log n), to klasa tych języków, które mogą być akceptowane w niedeterministycznej pamięci logarytmicznej, klasa coNL = coNSPACE (log n), to dopełnienie klasy tych języków, które mogą być akceptowane w niedeterministycznej pamięci logarytmicznej, Można wykazać że NL = coNL, ale niestety odpowiedź czy równość L = NL jest prawdziwa nie jest jeszcze znana?
V1.0 – 11/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Problem osiągalności
Problem osiągalności Problem osiągalności w grafie: Dany jest graf skierowany G oraz wierzchołki x i y . Pytanie jest następujące: czy istnieje ścieżka od x do y w G ? Można pokazać, że problem REACHABILITY jest NL-zupełny. Szkic dowodu: Należy pokazać, że problem REACHABILITY należy do NL. Użyte zostaną zmiennych v – wierzchołek bieżący, oraz u wierzchołek kolejny na ścieżce od x do y. Początkowo ustala się v := x. Dzięki niedetermizmowi, odgaduje się wierzchołek u i sprawdza się, czy jest sąsiedni do v . Jeśli nie, to obliczenia są przerywane, wiedząc, że na innej ścieżce obliczeń przetworzymy inne możliwości. Jeśli jest sąsiedni to sprawdzamy czy u = y co oznacza, że dotarliśmy do celu i akceptujemy parę x, y . W przeciwnym wypadku ustawiamy v := u i kontynuujemy obliczenia. V1.0 – 12/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Problem osiągalności
Problem osiągalności Szkic dowodu cd: Formalnie należy jeszcze użyć trzeciej zmiennej np.: o nazwie licznik, która zlicza liczbę kroków, tak aby ostatecznie odrzucić parę, gdy licznik przekroczy liczbę wierzchołków grafu. Ilość użytej pamięci jest rzędu log n, co kończy dowód pierwszego faktu. Teraz należy pokazać, że każdy inny problem z klasy NL redukuje się do REACHABILITY poprzez redukcję w pamięci logarytmicznej. Weźmy dowolny język L z klasy NL i odpowiadającą mu niedeterministyczną maszynę Turinga M. Rozmiar grafu konfiguracji maszyny działającej w pamięci log n, to c log n ∈ O(n), natomiast sprawdzenie czy x jest akceptowany przez M można sprowadzić do istnienia ścieżki od konfiguracji początkowej do akceptującej. Jest to zatem instancja problemu REACHABILITY na danych wielkości rzędu n. Nie ma potrzeby aby przeprowadzać konstrukcję całego grafu, a jedynie stwierdzać, czy dwie konfiguracje są sąsiednie, co daje się zrobić w pamięci logarytmicznej. Można też pokazać że osiągalność w grafie nieskierowanym należy do klasy L.
V1.0 – 13/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Problem osiągalności
Twierdzenie Immermana-Szelepcsényi’ego Klasy niedeterministyczne o złożoności pamięciowej są zamknięte na dopełnienie: Twierdzenie Immermana-Szelepcsényi’ego Jeśli f(n) jest konstruowalna pamięciowo, to NSPACE(f(n)) = coNSPACE(f(n)). Komentarz: Biorąc język L należący do NSPACE(f(n)), gdzie f (n) > log n, gdyż f(n) jest konstruowalna pamięciowo. Istnieje zatem maszyna niedeterministyczna M akceptująca L w pamięci niedeterministycznej. Należy pokazać, że istnieje maszyna niedeterministyczna M akceptująca L również w pamięci f(n). Biorąc graf konfiguracji M dla słowa wejściowego x. Musimy stwierdzić, czy nie istnieje ścieżka od konfiguracji początkowej do akceptującej. Wtedy bowiem x∈ / L czyli M 0 ma zaakceptować x.
V1.0 – 14/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Problem osiągalności
Twierdzenie Immermana-Szelepcsényi’ego
Komentarz cd: Oznaczmy konfigurację akceptującą przez y. Liczymy zatem zbiór S(n) dla grafu konfiguracji przy pomocy algorytmu z pierwszej części dowodu. Jeśli algorytm zakończy się wynikiem pozytywnym, to oznacza to, że s(n) jest policzone poprawnie. Jeśli zatem w trakcie przeglądania nie zakwalifikowaliśmy wierzchołka y do żadnego ze zbiorów S(i) to znaczy, że nie jest on osiągalny. W tej sytuacji maszyna M’ może zaakceptować słowo x, które nie należy do L, a tym samym pokazano, że L ∈ coNSPACE (f (n)).
V1.0 – 15/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Klasa coNP i DP
Klasa coNP Wiadomo że klasa NP, jest to zbiór tych języków, dla których możemy łatwo weryfikować przynależność słów. Klasa coNP natomiast, to zbiór tych języków, dla których możemy łatwo weryfikować, że słowo nie należy do języka. Przykłady problemów przynależących do klasy coNP: czy każde wartościowanie spełnia formułę φ, gdzie φ jest formuła logiczną jak dla problemu SAT, problem HAMILTON PATH COMPLEMENT, dla grafu nieskierowany G , pytamy się czy G nie zawiera ścieżki Hamiltona? Nie jest trudno udowodnić, że są to problemy zupełne dla klasy coNP. Nie jest to nic zaskakującego, bowiem równie prosto można udowodnić, że jeżeli L jest NP-zupełny, to jego dopełnienie L jest coNP-zupełne. Ważne pytanie, czy NP = coNP pozostaje otwarte. Można jedynie stwierdzić, że jeżeli P = NP, to NP = coNP, gdyż P jest zamknięta na dopełnienie. V1.0 – 16/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Klasa coNP i DP
Klasa coNP Pytanie, czy NP=coNP? Jeśli L jest coNP-zupełny i L ∈ NP to NP=coNP. Ustala się L z klasy NP, który jest coNP-zupełny. Niech L0 ∈ coNP. Ponieważ L jest coNP-zupełny, więc L’ redukuje się do L, czyli L’ należy do NP, bowiem redukcja jest procedurą deterministyczną. Analogicznie, weźmy dowolny L’ z NP. Wiemy, że L jest NP-zupełny, i należy do coNP. Możemy zatem sprowadzić L’ redukcją do L. Zatem L’ należy do coNP.
DP N
Pzu
p.
p. zu PN co
NP
P
coN
P V1.0 – 17/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Klasa coNP i DP
Klasa DP
Klasa DP to zbiór języków L takich, że L = L1 ∩ L2 , gdzie L1 ∈ NP natomiast L2 ∈ coNP. Problem EXACT TSP, jest problemem przynależącym do klasy DP. Pytamy się, czy dla danego ważonego grafu G i liczby K istnieje optymalna trasa komiwojażera dla G ma wartość dokładnie K ? EXACT TSP to dokładna wersja problemu komiwojażera. Wiadomo że problem TSP(D) jest NP-zupełny. Można również pokazać, że EXACT TSP i TSP(D) są wielomianowo równoważne, tzn., że jeśli jeden z nich ma rozwiązanie w czasie wielomianowym to drugi też. Choć nie wiadomo jak pokazać, że EXACT TSP należy do NP, to można poświadczyć i szybko zweryfikować, że długość optymalnej trasy wynosi dokładnie K. Bowiem, wymaga to stwierdzenia, że trasa ma długość co najmniej K i co najwyżej K, co sugeruje połączenie problemu TSP(D) i jego dopełnienia. V1.0 – 18/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Klasa coNP i DP
Przykłady problemów klasy DP
Inne przykłady problemów DP: problem SAT-UNSAT: dane są dwie formuły logiczne φ i ψ, pytanie jest następujące : czy formuła φ jest spełnialna, natomiast ψ niespełnialna? problem CRITICAL SAT: : czy formuła φ jest nie spełnialna, ale czy usunięcie dowolnej klauzuli sprawia, że jest spełnialna? problem CRITICAL HAMILTON PATH: czy graf nieskierowany G nie ma ścieżki Hamiltona, ale czy dodanie dowolnej krawędzi do G powoduje, że już ją posiada?
V1.0 – 19/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Klasa coNP i DP
Przykłady problemów klasy DP
Wiadomo też że, problem SAT-UNSAT jest DP-zupełny: Należy w pierwszej kolejności pokazać, że SAT-UNSAT należy do klasy DP. Trzeba wskazać stosowne języki L1 i L2 odpowiednio z klas NP i coNP. Wybieramy L1 = {(φ, ψ) : φ jest spełnialna} oraz L1 = {(φ, ψ) : ψ nie jest spełnialna}, o których można to łatwo stwierdzić. Dalej należty pokazać redukcję z dowolnego problemu z klasy DP. Dla L ∈ DP, wiadomo że L = L1 ∩ L2 i na mocy własności klas NP i coNP istnieją redukcje R1 języka L1 do SAT oraz R2 dopełnienia języka L2 do SAT (jako że L2 jest w coNP). Redukcja jest zdefiniowana jako R(x) = (R1 (x), R2 (x)). Na podstawie konstrukcji wiadomo, że x ∈ L1 , gdy R1 (x) jest spełniona oraz x ∈ L2 , gdy R2 (x) jest nie spełniona. Zatem x ∈ L1 ∩ L2 gdy R(x) ∈ SAT − UNSAT .
V1.0 – 20/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Maszyny Alternujące
Maszyny Alternujące
Maszyna alternująca ma więcej możliwości niż zwykła maszyna niedeterministyczna. Maszyna niedeterministyczna akceptuje słowo w , gdy na którejkolwiek ze ścieżek obliczeń maszyna trafi do stanu akceptującego. W przypadku maszyny alternującej wyróżnia się dwa stany „AND” lub „OR”, które nazywa się odpowiednio stanami uniwersalnymi i egzystencjalnymi. W przypadku gdy maszyna jest w stanie typu „OR”, to dokonuje akceptacji, gdy dowolna ze ścieżek obliczeń wychodzących z niego akceptuje słowo, jak zwykła maszyna niedeterministyczna. Stany typu „AND” są rozszerzają tą funkcjonalność. Maszyna dokonuje akceptacji będąc w takim stanie, gdy każda ze ścieżek obliczeń wychodzących z tego stanu jest akceptująca.
V1.0 – 21/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Maszyny Alternujące
Maszyny Alternujące Miary złożoności czasowej oraz pamięciowej maszyn alternujących definiuje się zupełnie tak jak dla maszyn niedeterministycznych, tzn. funkcja f(n) jest miarą złożoności czasowej, gdy każda ze ścieżek obliczeń ma długość ograniczoną przez f(n) oraz złożoność pamięciową f(n) gdy na każdej ze ścieżek obliczeń maszyna zużywa co najwyżej f(n) pamięci. Definicja ATIME(f(n)) Poprzez ATIME(f(n)) oznaczamy zbiór języków L takich, że są akceptowane przez alternującą maszynę Turinga M o złożoności czasowej f(n). Definicja ASPACE(f(n)) Poprzez ASPACE(f(n)) oznaczamy zbiór języków L takich, że są akceptowane przez alternującą maszynę Turinga M o złożoności pamięciowej f(n).
V1.0 – 22/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Maszyny Alternujące
Maszyny Alternujące Skróty dla najpopularniejszych klas są następujące: S klasa AP = ATIME (nk ) = j>0 ATIME (nj ), to klasa tych języków, które mogą być akceptowane w alternującym czasie wielomianowym, klasa AL = ASPACE (log n), to klasa tych języków, które mogą być akceptowane w alternującej pamięci logarytmicznej, Alternacja jest silniejsza niż niedeterminizm z racji definicji działania takich maszyn. Klasa AP zawiera w sobie NP. Szkic dowodu: Wiedząc, że TAUTOLOGY ∈ AP, a tym samym ponieważ AP jest zamknięta na redukcje, to cała klasa coNP zawiera się w AP. Maszyna dla TAUTOLOGY rozpoczyna działanie od stanu uniwersalnego. Następnie na każdej ze ścieżek obliczeń sprawdza inne wartościowanie. Jeśli φ jest spełniona na danym wartościowaniu, to obliczenie dochodzi do stanu akceptującego. W ten sposób ze względu na swój tryb działania, maszyna zaakceptuje φ, gdy jest ona spełniona dla każdego wartościowania, czyli, gdy jest tautologią logiczną. V1.0 – 23/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Maszyny Alternujące
Maszyny Alternujące Do klasy AP należy także problem MIN-FORMULA, tzn.: pytamy się czy φ jest minimalna, tzn. czy żadna krótsza formuła nie jest jej równoważna. Szkic dowodu: W pierwszej części maszyna działa w trybie „AND”. Zgadujemy formułę ψ krótszą niż φ, a następnie przestawiamy się na tryb „OR”. Teraz zgadujemy wartościowanie s. Jeśli φ i ψ są rozróżniane przez s, tzn. jedna z nich jest spełniona, a druga nie, to akceptujemy formułę φ. Należy załóżmy nie wprost, że formuła nie jest minimalna, ale zostaje zaakceptowana. Aby tak się stało na każdej ze ścieżek z pierwszego poziomu alternacji uniwersalnej maszyna musi zaakceptować. Jeśli jednak formuła nie jest minimalna, to istnieje krótsza od niej formuła ψ, które jest jej równoważna. Na ścieżce obliczeń rozważającej ψ maszyna w drugim poziomie alternacji musi znaleźć wartościowanie, które rozróżnia φ i ψ co jest niemożliwe, stąd uzyskujemy sprzeczność.
V1.0 – 24/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Maszyny Alternujące
Maszyny Alternujące
Relacje pomiędzy klasami obliczeń alternujących są następujące: jeśli f (n) > n to ATIME (f (n)) ⊆ SPACE (f (n)), jeśli f (n) > n to SPACE (f (n)) ⊆ ATIME (f 2 (n)), jeśli f (n) > log n to ASPACE (f (n)) ⊆ TIME (c f (n) ), jeśli f (n) > log n to ASPACE (f (n)) ⊇ TIME (c f (n) ). Dzięki wymienionym relacjom pomiędzy klasami alternującymi możliwe jest udowodnienie dokładnych równości pomiędzy klasami, min. jest prawdą iż: AL=P, APSPACE = EXP, AP=PSPACE.
V1.0 – 25/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Hierarchia wielomianowa
Hierarchia wielomianowa Można określić całą hierarchię klas ponad klasami P i NP, która stanowi pewne uogólnienie klasie DP. W hierarchii wykorzystano pojęcie maszyny z wyrocznią na język L oznaczanej przez M L . Przypomnijmy, że jest to zwykła maszyna M z dodatkową możliwością zadania pytania postaci czy x ∈ L, które kosztuje jedną jednostkę czasu. Poprzez P NP oznacza się zbiór tych języków, które mogą być rozstrzygane przez maszyny z klasy P z wyrocznią. Taka klasa okazuje się mocniejsza od DP, bowiem w DP mogliśmy zadań pytanie tylko raz (dotyczące coNP, ale w sensie wyroczni działa to jak pytanie do NP), a w hierarchi dowolną liczbę razy. Dopuszczalne są także pytania adaptywne, tzn. takie, które mogą zależeć od wyników odpowiedzi na poprzednie pytania. Kolejną interesującą klasą jest NP NP . Wszystkie te klasy dają nam coraz większe możliwości, lecz niestety nie wiadomo, czy są to ściśle większe klasy V1.0 – 26/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Hierarchia wielomianowa
Hierarchia wielomianowa
Wielomianowa hierarchię klas Meyer i Stockmeyer: Hierarchia wielomianowa Hierarchia wielomianowa, to ciąg klas indeksowany poprzez i: PP QP P 0 = ∆0 = P, 0 = PP
∆Pi+1 = P i , dla i > 0, PP PP i , dla i > 0, i+1 = NP PP QP i , dla i > 0. i+1 = coNP Dodatkowo PH oznaczamy sumę wszystkich tych klas, czyli: S poprzez P PH = i>0 i P.
V1.0 – 27/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Hierarchia wielomianowa
Hierarchia wielomianowa
V1.0 – 28/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Pamięć wielomianowa i złożoność wykładnicza
V1.0 – 29/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Klasa PSPACE
Klasa PSPACE Klasa PSPACE, kto klasa tych języków, które są akceptowane przez maszynę deterministyczną w pamięci wielomianowej. Oczywiśćie PSPACE posiada również problemy zupełnych. Zupełność definiujemy jest przy pomocy wielomianowej redukcji. Problem QSAT gdzie dla sprawdza się czy formuła logiczna φ określona jak dla problemu SAT poprzedzona dowolną liczbą naprzemiennych kwantyfikatorów: Φ = ∃x1 ∀x2 ∃x3 . . . Qxk φ jest prawdziwa, naturalnie jest problemem PSPACE-zupełnym. Inne przykłady problemów PSPACE-zupełnych: problem IN PLACE ACCEPTANCE (akceptacja w miejscu), dajemy odpowiedź czy maszyna M akceptuje słowo x używając |x| pamięci? Problem IN PLACE DIVERGENCE (rozbieżność w miejscu)], dajemy odpowiedź czy maszyna M zapętli się używając |M| pamięci?
V1.0 – 30/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Klasa PSPACE
Klasa PSPACE
Klasa PSPACE obejmuję grupę problemów opartych na grach. Ze względu na fakt, że QSAT może w pewnej interpretacji obrazować grę dwuosobową. Kwantyfikator egzystencjalny odpowiada ruchowi gracza, który wybiera jedną z możliwości. Kwantyfikator uniwersalny odpowiada dowolnej odpowiedzi drugiego gracza. Strategia wygrywająca to taki algorytm, który pozwala wygrać pierwszemu graczowi, niezależnie od ruchów podjętych przez drugiego. Przykładem może być gra FORMULA GAME powiązana z formułą QSAT która polega na znalezieniu wartościowania spełniającego dla zmiennych przez pierwszego gracza (drugi stara się mu w tym przeszkodzić). Kolejne ruchy graczy to wybory wartości dla zmiennych x1 , . . . , xk . Na końcu następuje sprawdzenie prawdziwości formuły bez kwantyfikatorów.
V1.0 – 31/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Klasa PSPACE – problemy zupełne
Klasa PSPACE – problem zupełny FORMULA GAME jest problemem PSPACE-zupełnym. Szkic dowodu: Po wskazaniu odpowiedniości pomiędzy QSAT i FORMULA GAME redukcja jest dość łatwa do wyznaczenia. Istnienie strategii może zostać sprawdzone w pamięci wielomianowej poprzez sprawdzenie wszystkich wartościowań stosownie do reguł gry, zupełnie tak jak działo się w dowodzie, że QSAT należy do PSPACE. Teraz redukcja QSAT do FORMULA GAME. Opiera się ona na własności strategii wygrywającej. Należy rozważyć Φ = ∃x1 ∀x2 ∃x3 . . . Qxk φ. W przypadku, gdy posiadamy strategię wygrywającą, to istnieje taki wybór x1 , który sprawia, że osiągniemy sukces. Taką dokładnie wartość wybieramy dla x1 kwantyfikowanej egzystencjalnie. Następnie gracz II wykonuje dowolny ruch, ale obrana strategii przewiduje takie zachowanie – dlatego φ będzie prawdziwa, przy dowolnym wartościowaniu x2 i etc. Ostatecznie formuła Φ jest prawdziwa wtedy i tylko wtedy, gdy istnieje strategia wygrywająca dla FORMULA GAME. Gdyż redukcja przepisuje formułę Φ bezpośrednio. V1.0 – 32/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Klasa PSPACE – problemy zupełne
Klasa PSPACE – Geography Kolejny problem PSPACE-zupełny to gra GEOGRAPHY, polegająca na kolejnym wypowiadaniu przez graczy nazw miast w ten sposób, aby każde kolejne zaczynało się na taką literą na jaką kończy się poprzednie. Nie można używać miast wielokrotnie. Przegrywa ten, kto nie może wykonać ruchu.
V1.0 – 33/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Klasa PSPACE – problemy zupełne
Klasa PSPACE – Geography Problem GEOGRAPHY Dany jest graf G i wierzchołek początkowy x, czy gracz I ma strategię wygrywającą? Szkic dowodu: W pierwszej kolejności należy pokazać, że GEOGRAPHY należy do PSPACE. Argument jest podobny do przypadku dal QSAT. Konstruujemy algorytm rekurencyjny, który przegląda wszystkie możliwe przebiegi rozgrywki i stosownie odpowiada na pytanie. Wykorzystuje się odpowiedniość pomiędzy kwantyfikatorem egzystencjalnym i ruchem pierwszego gracza, oraz kwantyfikatorem uniwersalnym oraz ruchem drugiego gracza w analizie strategii wygrywającej. Ponieważ liczba ruchów jest ograniczona przez liczbę wierzchołków G zatem taka symulacja może odbyć się w pamięci wielomianowej. Następnie należy zredukować problem QSAT do GEOGRAPHY. Inaczej mówiąc biorąc dowolną formułę Φ i przekształcamy ją w planszę do GEOGRAPHY. Przykład postępowania dla formuły Φ = ∃x∀y ∃z((¬x ∨ ¬y ) ∧ (y ∨ z) ∧ (y ∨ ¬z)) został przedstawiony na rysunku. V1.0 – 34/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Klasa PSPACE – problemy zupełne
Klasa PSPACE – Geography Szkic dowodu:
V1.0 – 35/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Klasa PSPACE – problemy zupełne
Klasa PSPACE – Geography Szkic dowodu: Konstrukcja nie jest trudna. Pierwszy występujący ciąg rombów odpowiada wartościowaniu zmiennych formuły. Należy zwrócić uwagę, że plansza jest tak skonstruowana, iż wartości dla kolejnych zmiennych są wybierane przez graczy na zmianę. Tym samym gracz I ustala wartości zmiennych kwantyfikowanych egzystencjalnie, a gracz II uniwersalnie. Gdy gra dochodzi do dolnej części rysunku, to gracz II (dla wygody zakłada się, że zmiennych jest nieparzysta ilość) wybiera wyjście odpowiadające klauzuli (w tej interpretacji wybiera klauzulę niespełnioną). Następnie gracz I wykonuje ruch, który jest możliwy wtedy i tylko wtedy, gdy w klauzuli istnieje literał spełniony. Gracz II nie ma wtedy kolejnego ruchu. W ten sposób pokazano strategię wygrywającą dla gracza I jest równoważna prawdziwości formuły QSAT.
Wielomianowe ograniczenie liczby możliwych ruchów (np.: poprzez rozmiar planszy) decyduje o tym iż gry dwuosobowe należy do PSPACE. Również gra GO także jest przykładem problemu PSPACE-zupełnego. V1.0 – 36/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Złożoność wykładnicza
Złożoność wykładnicza
Twierdzenie o hierarchii czasowej i pamięciowe wskazuje naturalnie iż PSPACE nie obejmuje wszystkich języków. k
klasa EXPSPACE = SPACE (2n ), to klasa tych języków, które mogą być akceptowane w deterministycznej pamięci wykładniczej, k
klasa NEXPSPACE = NSPACE (2n ), to klasa tych języków, które mogą być akceptowane w niedeterministycznej pamięci wykładniczej. k
klasa EXP = TIME (2n ), to klasa tych języków, które mogą być akceptowane w deterministycznym czasie wykładniczym, k
klasa NEXP = NTIME (2n ), to klasa tych języków, które mogą być akceptowane w niedeterministycznym czasie wykładniczym.
V1.0 – 37/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Złożoność wykładnicza
Złożoność wykładnicza Dzięki twierdzeniu Savitcha wiadomo, że EXPSPACE = NEXPSPACE oraz zachodzi także: PSPACE ⊆ EXP ⊆ NEXP ⊆ EXPSPACE co w połączeniu z faktem z twierdzenia hierarchii, że PSPACE zawiera się ściśle w EXPSPACE pozwala twierdzić, że przynajmniej jedna z powyższych trzech nierówności jest ścisła, niestety nie wiadomo która. Podobnie: P ⊆ NP ⊆ PSPACE ⊆ EXP oraz wiadomo, że P zawiera się ściśle w EXP, na podstawie twierdzenia o hierarchii czasowej. Stąd ponownie jedna z trzech nierówności musi być ścisła, choć nie wiadomo która. Prawdopodobnie wszystkie. Ale najważniejsze pytanie, to czy EXP=NEXP?
V1.0 – 38/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
P = NP ⇒ EXP = NEXP
P = NP → EXP = NEXP Jeśli P=NP to EXP=NEXP Szkic dowodu: Weźmy dowolny język L z NEXP i pokażmy, dzięki równości NP i P, że należy on do EXP. Załóżmy, że L jest akceptowany przez maszynę niedeterministyczną N w k czasie 2n . Wprowadzimy teraz język L’, które powstaje na podstawie L: |x|k
L0 = {x#02
−|x|
: x ∈ L},
czyli innymi słowy wszystkie słowa z L, lecz unormowane do odpowiedniej długości przy użyciu symboli quasi-blanków (oznaczone symbolem #0 są odróżnialne od symbolu pustego). Język L’ należy teraz do NP. Maszyna N’, która tego dokonuje sprawdza, czy słowo ma odpowiednią długość, a następnie symuluje działanie N. Dzięki wykładniczym „rozszerzeniu” słowa wejściowego maszyna N’ ma złożoność wielomianową względem rozmiaru danych (nawet liniową). V1.0 – 39/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
P = NP ⇒ EXP = NEXP
P = NP ⇒ EXP = NEXP Szkic dowodu cd: Na podstawie założenia P=NP wiadomo, że istnieje wielomianowa maszyna deterministyczna M’, która akceptuje L’ w czasie nl . Teraz dokonujemy przekształcenia w odwrotnym kierunku, otrzymując maszynę deterministyczną l M, która akceptuje L w deterministycznym czasie wykładniczym 2n , co pokazuje, że L należy do EXP. Konstrukcja M to symulacja maszyny M’ na słowie wejściowym. Bez straty ogólności można założyć, że maszyna traktuje taśmę wejściową jako tylko do odczytu. W tej sytuacji musimy tylko pamiętać pozycję w ciągu quasiblanków, co nie przedstawia trudności. Wniosek Jeśli g (n) > n i f(n) są konstruowalne czasowo, to TIME(f (n)) = NTIME(f (n)) ⇒ TIME(g (f (n))) = NTIME(g (f (n))).
V1.0 – 40/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
P = NP ⇒ EXP = NEXP
Komentarz Wszystkie wspomniane klasy złożoności wykładniczej posiadają problemy zupełne. Co warte podkreślenia, na podstawie twierdzeń o hierarchii czasowej klasa EXP nie może zapaść się do P, więc problemy EXP-zupełne nie mają rozwiązania wielomianowego, czyli nie należą do P! Problemy EXPSPACE-zupełne również nie należą do PSPACE, a zatem nie należą także do NP! Na podstawie twierdzeń o hierarchii wiadomo, że można wyróżnić coraz trudniejsze problemy i coraz istotnie większe klasy. Przykładem są klasy złożoności podwójnie wykładniczej 2EXP i 2NEXP, o których nie wiadomo czy są równe. Jedną z ciekawych klas jest ELEMENTARY, która jest sumą klas: nk
TIME (2
..2 2.
)
i nazywa się ją klasą języków elementarnych. Są jednak problemy, które i do tej klasy nie należą. Największą klasą przedstawioną w animacji Hierarchia klas złożoności obrazującym zależności pomiędzy poznanymi klasami złożoności jest R - klasa wszystkich języków rozstrzygalnych. Istnieje też klasa wszystkich klas i nazywa się ją klasą ALL. V1.0 – 41/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
P = NP ⇒ EXP = NEXP
Zamiast rysunku
https://complexityzoo.uwaterloo.ca/Complexity_Zoo
V1.0 – 42/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
Wyrażenia regularne
Wyrażenia regularne
Wiadomo, że dla wyrażeń regularnych R i S, następujace pytanie: czy R i S są równoważne (opisują ten sam język)? jest problemem PSPACE zupełnym. Jednak dodatkowy operator potęgowania: k
z }| { R = R ↑ k = R ◦ R ◦ . . . ◦ R, k
Powoduje, że problem staje problemem EXPSPACE-zupełnym. Jednakże dodanie kolejnego operatora negacji, powoduje że problem równoważności uogólnionych wyrażeń regularnych przestaje być problemem elementarnym.
V1.0 – 43/ 44
Wprowadzenie
Dopełnienia klas
PLiHW
PWiZW
A za tydzień na wykładzie
W następnym tygodniu między innymi
1
Informatyka kwantowa
2
Twierdzenie o nieklonowaniu
3
Stany czyste, mieszane i splątane
4
Bramki i obwody kwantowe
5
Operacje pomiaru
6
Problem Deutscha
Dziękuje za uwagę!!!
V1.0 – 44/ 44
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Wstęp do obliczeń kwantowych Osoba prowadząca wykład i ćwiczenia: dr inż. Marek Sawerwain Instytut Sterowania i Systemów Informatycznych Uniwersytet Zielonogórski e-mail : [email protected] tel. (praca) : 68 328 2321, pok. 328a A-2, ul. prof. Z.Szafrana 2, 65-246 Zielona Góra
Ostatnia zmiana: 22 stycznia 2013
V1.0 – 1/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Spis treści 1
Wprowadzenie Plan wykładu
2
Algorytmy randomizowane Algorytmy randomizowane – zalety Algorytmy randomizowane – oczekiwane własności
3
Obliczenia kwantowe Teza Churcha-Turinga oraz wypowiedź Richarda P.Feynmana Modele obliczeniowe Qubit, rejestry, bramki, obwody Qubit, qudit, rejestr kwantowy Bramki kwantowe Operacja pomiaru Uniwersalne zbiory bramek Twierdzenie o nie-klonowaniu stanów kwantowych Obwody kwantowe Kwantowa teleportacja deterministyczna Algorytm Deutscha–Jozsy
4
A za tydzień na wykładzie
V1.0 – 2/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Plan wykładu
Plan wykładu – spotkania tydzień po tygodniu
(1) Informacje o wykładzie, poprawność algorytmów (2) Poprawność algorytmów – logika Hoarego (3) Analiza złożoności kodu wysokiego i niskiego poziomu (4) Modele algorytmiczne – maszyny proste, obwody logiczne (5) Modele algorytmiczne – maszyna Turinga oraz rachunek-λ (6) Automaty (nie)deterministyczne – część I (7) Automaty (nie)deterministyczne – część II (8) Gramatyki regularne i bezkontekstowe
V1.0 – 3/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Plan wykładu
Plan wykładu – spotkania tydzień po tygodniu
(9) Gramatyki i automaty ze stosem (10) Algorytmy równoległe (11) Klasy złożoności obliczeniowej (12) Pamięć logarytmiczna i wielomianowa (13) Problemy NP-zupełne (14) ⇒ Wstęp do obliczeń kwantowych ⇐ (15) Wybrane algorytmy kwantowe
V1.0 – 4/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Plan wykładu
Plan wykładu
1
Algorytmy randomizowane: 1 2 3 4
2
czy warto stosować tego typu rozwiązania, podstawowe własności, problem maksymalnego przekroju, problem maksymalnego przekroju – przykład.
Obliczenia kwantowe 1 2 3 4 5 6 7 8
Teza Churcha-Turinga oraz wypowiedz Richarda P.Feynmana Modele obliczeniowe Qubit, rejestry, bramki, obwody Operacja pomiaru Uniwersalne zbiory bramek Twierdzenie o nie-klonowaniu stanów kwantowych Kwantowa teleportacja deterministyczna Algorytm Deutscha–Jozsy
V1.0 – 5/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Plan wykładu
Materiały wykorzystane podczas tworzenia tego wykładu, a także przydatne do dalszych studiów: 1 Algorytmy Randomizowane: http://wazniak.mimuw.edu.pl/index.php?title=Zaawansowane_ algorytmy_i_struktury_danych/Wyk\T1\lad_15 2
Michael A. Nielsen, Isaac L. Chuang, Quantum Computation and Quantum Information, Cambridge University Press, Cambridge, 2000,
3
Mika Hirvensalo, Quantum Computing, Natural Computing Series, Springer-Verlag, Berlin, 2001, (jest też polskie wydanie)
4
Krzysztof Giaro, Marcin Kamiński, Wprowadzenie do algorytmów kwantowych, Akademicka Oficyna Wydawnicza EXIT, Warszawa 2003.
5
J. Preskil, Lecture notes for Physics 229: Quantum Information and Computation, Cambridge University Press, 1998.
6
J. Gruska, Quantum Computing, McGraw Hill, Cambridge University Press, 1999
V1.0 – 6/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Obliczenia kwantowe
V1.0 – 7/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Algorytmy randomizowane – zalety
Algorytmy randomizowane Jednym z ważniejszych powodów używania algorytmów randomizowanych jest bardzo często ich prostota. Istnieje wiele przykładów, w których efektywność prostego algorytmu randomizowanego może równać się (a nawet być większa) efektywności algorytmu deterministycznego. Znakomitym przykładem potwierdzającym tego typu podejście są np.: algorytmu sortujące. Istnieje wiele deterministycznych algorytmów sortujących działających w asymptotycznym czasie O(n log n), np. algorytm Merge-Sort. Jednakowoż, praktyce bardzo często stosowany jest algorytm Quick-sort, którego oczekiwany czas działania to O(n log n). Jednakże algorytm ten jest dość prosty do implementacji i działa zazwyczaj szybciej niż bardziej złożone algorytmy deterministyczne. Inną zaletą jest szybkość. Dla niektórych znanych problemów opracowane algorytmy randomizowane są szybsze a nawet dużo szybsze od tych deterministycznych. Może tak być, ponieważ dla algorytmów randomizowanych żąda się tylko aby poprawna odpowiedź była zwrócona z dużym prawdopodobieństwem, bądź aby działały one w oczekiwanym czasie wielomianowym. Niestety, to także oznacza, że w niektórych przypadkach algorytm randomizowany może w ogóle nie znaleźć poprawnej odpowiedzi lub może ją znaleźć, ale po bardzo długim czasie. V1.0 – 8/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Algorytmy randomizowane – zalety
Algorytmy randomizowane Algorytmy randomizowane mogą być algorytmami typu online. A są to algorytmy podejmujące decyzje dla danego problemu na podstawie częściowej wiedzy na temat danych wejściowych, na przykład gdy przyszłe dane wejściowe nie są znane. W takiej sytuacji losowość jest użyteczna, ponieważ pozwala na uniezależnienie się od nieznanego ciągu danych, który może być dobrany w sposób pesymistyczny. Ograniczenie złożoności komunikacji. Za przykład może posłużyć następująca gra z dwoma graczami: Eva i Bob. Każdy z nich ma ciąg n-bitów i chcą je porównać, aby sprawdzić czy są one takie same. Jednakże, za każdy wysłany bit muszą zapłacić. Najlepszy algorytm deterministyczny dla tego problemu wymaga wysłania n bitów. Zasadniczo to jest równoważne wysłaniu przez Evę całego ciągu do Boba. Z drugiej poprzez użycie randomizacji wymagana komunikacja może być zredukowana, jednak przy osłabieniu wymagań, a mianowicie można tylko określić, aby protokół się powiódł z wysokim prawdopodobieństwem. W tym celu Eva i Bob muszą posiadać ten sam ciąg n losowych bitów, a ciągi są porównane poprzez porównanie jednobitowej wartości iloczynu skalarnego ciągu z tym ciągiem losowym. V1.0 – 9/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Algorytmy randomizowane – oczekiwane własności
Algorytmy randomizowane – oczekiwane własności Liniowość wartości oczekiwanej: podstawową właściwością zmiennych losowych, która znajduje zastosowanie w algorytmach randomizowanych, jest wykorzystanie liniowości wartości oczekiwanych. Niech X i Y będą zmiennymi losowymi. Zachodzi wtedy następująca równość: E[X + Y ] = E[X ] + E[Y ]. Równość ta nie wymaga niezależności pomiędzy X i Y. Przykład wykorzystania tej własności: w klasie jest 26 uczniów i nauczyciel ma ciastka, na których są litery alfabetu (każde ciastko ma inną literkę). Przypuśćmy, z nauczyciel rozdaje po jednym ciastku każdemu uczniowi. Jaka jest oczekiwana liczba uczniów, którzy dostaną ciastko z literą, która jest pierwszą literą ich imienia?
V1.0 – 10/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Algorytmy randomizowane – oczekiwane własności
Algorytmy randomizowane – oczekiwane własności Należy, rozważyć zmienne losowe : X1 , X2 , . . . , X26 , gdzie dla każdego i, 1 ≤ i ≤ 26 definiuje się ( 1 jeżeli i’ta osoba otrzyma właściwą literę, Xi = 0 w przeciwnym przypadku. Ponieważ ciastka były losowo rozdzielone, prawdopodobieństwo tego, że 1 1 n’ta osoba dostanie prawidłową literkę wynosi 26 . Toteż E[Xi ] = 26 dla wszystkich i. Ostatecznie, oczekiwana liczba osób z właściwą literką na ich ciastku wynosi: E[X1 + X2 + . . . + X26 ] =
26 X i=1
E[Xi ] = 1
Należy przy tym zaznaczyć, że nie poczyniono żadnych założeń odnośnie pierwszej litery imion uczniów. V1.0 – 11/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Algorytmy randomizowane – oczekiwane własności
Algorytmy randomizowane – oczekiwane własności Liniowość wariancji. Jeżeli zmienne losowe są od siebie niezależne, to ich wariancja też jest liniowa. Dla n niezależnych zmiennych losowych X1 , X2 , . . . , Xn to mamy: ! Pn n X i=1 Var (Xi ) Var Xi = . n2 i=1
Własność ta znajduje zastosowanie w połączeniu z nierównością Czebyszewa bądź Czernoffa, gdy należy obniżyć prawdopodobieństwo błędu, bądź wielkość tego błędu. Możemy wtedy pobierać losową próbę, tzn. pobrać małą próbę z dużego zbioru danych wejściowych. Zadany problem można rozwiązać na tej małej próbie, po czym uzyskanym wynikiem można posłużyć się dla problemu właściwego.
V1.0 – 12/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Algorytmy randomizowane – oczekiwane własności
Algorytmy randomizowane – oczekiwane własności
Randomizacja jest bardzo dobrą metodą na rozłożenie obciążenia. Dla przykładu rozważmy sytuację w której mamy n serwerów i n zadań. Jeżeli każde z n zadań zostanie przydzielone do jednego serwera w sposób losowy, wtedy z dużym prawdopodobieństwem żadna z maszyn nie otrzymuje więcej niż log n zadań. Możemy delikatnie poprawić tą prostą randomizowaną strategię: dla każdego zadania wybieramy losowo dwa serwery i przydzielamy to zadanie serwerowi o mniejszym obciążeniu. Można pokazać, że ten zmodyfikowany schemat z dużym prawdopodobieństwem nie przydzieli więcej niż log log n zadań dla każdego serwera. W ten sposób, w przypadku miliona zadań, każdy serwer otrzyma co najwyżej pięć zadań. Stwierdzenie z dużym prawdopodobieństwem oznacza, że jakaś własność zajdzie z prawdopodobieństwem większym niż 12 .
V1.0 – 13/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Algorytmy randomizowane – oczekiwane własności
Algorytmy randomizowane – oczekiwane własności W obliczeniach równoległych i rozproszonych ważne jest, aby złamać symetrię między procesorami (łamanie symetrii). Przykładem jest sieć Ethernet, kiedy dwie maszyny wysyłają pakiet danych w tym samym czasie, następuje kolizja. Nie wiadomo, który procesor powinien spróbować ponownie przesłać pakiet. Gdy uczynią to obydwa, znów nastąpi kolizja. Najprostszym sposobem na uniknięcie tej sytuacji jest złamanie symetrii poprzez randomizację, np. każdy procesor rzuca monetą i próbuje ponownie wysłać pakiet, gdy wypadła mu reszka. Kolejnym przykładem jest problem znalezienia doskonałego skojarzenia w grafie na maszynie równoległej. Ważne jest, aby wszystkie procesory obliczały to samo skojarzenie, jednak nie wiadomo które, bo jeszcze go nie znaleźliśmy. Tutaj można posłużyć się randomizacją w celu złamania symetrii pomiędzy różnymi możliwymi skojarzeniami i odizolowaniem pojedynczego skojarzenia. Niektóre proste algorytmy randomizowane mogą być przerobione na (nie takie znów proste) algorytmy deterministyczne poprzez derandomizację. Często w ten sposób dostaje się najefektywniejsze algorytmy deterministyczne.
V1.0 – 14/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Algorytmy randomizowane – oczekiwane własności
Problem maksymalnego przekroju W problemie maksymalnego przekroju dany jest graf G = (V , E ) oraz |V | = n i |E | = m , a wynikiem jest podział zbioru wierzchołków na dwa podzbiory (A, B). Krawędź jest rozcięta wtedy, gdy jej końce leżą po dwóch różnych stronach podziału. Istotą problemu jest znalezienie takiego podziału, który maksymalizuje liczbę krawędzi rozciętych. Problem ten jest NP-trudny. Używając randomizacji, łatwo zbudować prosty aproksymacyjny algorytm dla tego problemu. Twierdzenie Istnieje podział (A, V - A) zbioru wierzchołków taki, że: liczba krawędzi w zbiorze >
|E | m = . 2 2
V1.0 – 15/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Algorytmy randomizowane – oczekiwane własności
Problem maksymalnego przekroju Szkic dowodu: Budujemy zbiór A (to znaczy jedną stronę podziału) włączając każdy wierzchołek do A z prawdopodobieństwem 12 . Należy zadać pytanie: jaka jest oczekiwana liczba rozciętych krawędzi dla podziału (A, V − A)? Aby odpowiedzieć na to pytanie, dla każdej krawędzi (i, j) ∈ E , definiuje się ( 1 jeżeli krawędź (i, j) jest rozcięta, xXi,j = 0 w przeciwnym przypadku. Co pozwala określić, że liczba rozciętych krawędzi wynosi: X Liczba rozciętych krawędzi = X = Xi,j . (i,j)∈E
V1.0 – 16/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Algorytmy randomizowane – oczekiwane własności
Problem maksymalnego przekroju
Szkic dowodu cd: Właściwe pytanie sprowadza się teraz do wyznaczenia wartości E[X ]. Posłużymy się liniowością wartości oczekiwanych. Po pierwsze należy zauważyć, że E[Xi,j ] = 12 . Jest tak, ponieważ niezależnie od tego, czy i jest w zbiorze A czy nie, jest dokładnie jeden wybór dla j, który rozetnie krawędź (i, j). Stąd otrzymuje się: E[X ] =
X (i,j)∈E
E[Xi,j ] =
X 1 m = . 2 2
(i,j)∈E
Aby zakończyć dowód, trzeba zaobserwować, że musi istnieć podział dla którego liczba rozciętych krawędzi jest równa co najmniej średniej, czyli m2 .
V1.0 – 17/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Algorytmy randomizowane – oczekiwane własności
Problem maksymalnego przekroju
Przykładowy graf ilustrujący aproksymacyjny algorytm dot. problemy maksymalnego przekroju.
V1.0 – 18/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Algorytmy randomizowane – oczekiwane własności
Problem maksymalnego przekroju Przykładowy graf ilustrujący aproksymacyjny algorytm dot. problemy maksymalnego przekroju. 0
1
0
1
0
0
Dla każdego wierzchołka należy losowo przydzielić wartość zero bądź jedność.
V1.0 – 19/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Algorytmy randomizowane – oczekiwane własności
Problem maksymalnego przekroju Przykładowy graf ilustrujący aproksymacyjny algorytm dot. problemy maksymalnego przekroju. 0
1
0
1
0
0
Wierzchołki dla których wylosowane jedność zostają przydzielone do zbioru A. Pozostałe należą do zbiory V − A. Rozmiar rozcięcia wynosi trzy. V1.0 – 20/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Algorytmy randomizowane – oczekiwane własności
Problem maksymalnego przekroju Przykładowy graf ilustrujący aproksymacyjny algorytm dot. problemy maksymalnego przekroju. 1
1
1
1
1
0
Nowe losowanie.
V1.0 – 21/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Algorytmy randomizowane – oczekiwane własności
Problem maksymalnego przekroju Przykładowy graf ilustrujący aproksymacyjny algorytm dot. problemy maksymalnego przekroju.
1
1
1
1
1
0
Teraz wartość rozcięcia wynosi dwa. V1.0 – 22/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Algorytmy randomizowane – oczekiwane własności
Problem maksymalnego przekroju Przykładowy graf ilustrujący aproksymacyjny algorytm dot. problemy maksymalnego przekroju. 0
0
1
0
1
0
Nowe losowanie.
V1.0 – 23/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Algorytmy randomizowane – oczekiwane własności
Problem maksymalnego przekroju Przykładowy graf ilustrujący aproksymacyjny algorytm dot. problemy maksymalnego przekroju. 0
1
0
0
1
0
Teraz wartość rozcięcia wynosi cztery. V1.0 – 24/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Algorytmy randomizowane – oczekiwane własności
Problem maksymalnego przekroju Przykładowy graf ilustrujący aproksymacyjny algorytm dot. problemy maksymalnego przekroju. 0
1
1
0
1
1
Nowe losowanie.
V1.0 – 25/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Algorytmy randomizowane – oczekiwane własności
Problem maksymalnego przekroju Przykładowy graf ilustrujący aproksymacyjny algorytm dot. problemy maksymalnego przekroju. 0
1
1
0
1
1
Wartość rozcięcia ponownie wynosi cztery. V1.0 – 26/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Algorytmy randomizowane – oczekiwane własności
Problem maksymalnego przekroju Przykładowy graf ilustrujący aproksymacyjny algorytm dot. problemy maksymalnego przekroju. 1
1
1
1
1
1
Nowe losowanie.
V1.0 – 27/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Algorytmy randomizowane – oczekiwane własności
Problem maksymalnego przekroju Przykładowy graf ilustrujący aproksymacyjny algorytm dot. problemy maksymalnego przekroju.
1
1
1
1
1
1
Wartość rozcięcia ponownie wynosi zero. V1.0 – 28/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Algorytmy randomizowane – oczekiwane własności
Problem maksymalnego przekroju Przykładowy graf ilustrujący aproksymacyjny algorytm dot. problemy maksymalnego przekroju. 1
0
1
0
1
0
Nowe losowanie.
V1.0 – 29/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Algorytmy randomizowane – oczekiwane własności
Problem maksymalnego przekroju Przykładowy graf ilustrujący aproksymacyjny algorytm dot. problemy maksymalnego przekroju. 1
0
1
0
1
0
Wartość rozcięcia wynosi trzy. A ogólnie wartość oczekiwana wynosi 3.5. W dwóch losowaniach otrzymano rozcięcie większe a w trzech mniejsze. Liczba rozciętych krawędzi w najlepszym podziale nie może przekraczać m. Algorytm daje przecięcie wielkości m2 . Stąd oczekiwana aproksymacja wyniku to 12 .
V1.0 – 30/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Obliczenia kwantowe
V1.0 – 31/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Teza Churcha-Turinga oraz wypowiedź Richarda P.Feynmana
Teza Churcha-Turinga Teza Churcha-Turinga: Any model of computation can be simulated on a probabilistic Turing machine with at most a polynomial increase (i.e. efficiently) in the number of elementary operations required. Strong Church-Turing thesis (late 60s)
Wniosek z tezy jest następujący, jeśli dany problem jest trudny do rozwiązania to takim pozostanie dla każdego klasycznego komputera którego model obliczeniowy można przedstawić za pomocą maszyny Turinga i wielomianowej ilości operacji elementarnych. Jednak komputer kwantowy potrafi realizować trudne problemy w czasie krótszym nie osiągalnym dla komputerów klasycznych. Co pozwala na postawienie następującego stwierdzenia albo lepiej pytania: czy hipoteza Churcha-Turinga jest czy też nie jest prawdziwa. V1.0 – 32/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Teza Churcha-Turinga oraz wypowiedź Richarda P.Feynmana
Wypowiedź Richarda P.Feynmana Warto przytoczyć wypowiedź Richarda P.Feynmana, który zwrócił uwagę na fakt, iż współczesne mu komputery są dalece niewystarczalne, aby przeprowadzić w pełni symulację wielu złożonych procesów fizycznych, ze szczególnym uwzględnieniem procesów kwantowych. Warto zacytować fragmenty jego wypowiedzi, a w oryginalnie brzmią one następująco: Can physics be simulated by a universal computer? [...] the physical world is quantum mechanical, and therefore the proper problem is the simulation of quantum physics [...] the full description of quantum mechanics for a large system with R particles [...] has too many variables, it can not be simulated with a normal computer with a number of elements proportional to R [... but it can be simulated with] quantum computer elements. [...] Can a quantum system be probabilistically simulated by a classical (probabilistic, I’d assume) universal computer? [...] If you take the computer to be the classical kind I’ve described so far [...] the answer is certainly, No! V1.0 – 33/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Teza Churcha-Turinga oraz wypowiedź Richarda P.Feynmana
Wypowiedź Richarda P.Feynmana – komentarz Stwierdzenie to nadal jest aktualne, bowiem po ponad 30 latach rozwoju technologii informatycznej, licząc od daty wystąpienia Richarda P. Feynmana, maszyny cyfrowe nadal nie oferują dostatecznej mocy obliczeniowej, choć moc ta, jest znacznie większa niż w latach 80-tych XX wieku. Pierwszy superkomputer ze słynnej firmy Cray, w roku 1976 oferował moc obliczeniową na poziomie 80 MFLOPS, wielkość ta w krótkim czasie została zwiększona do 136 MFLOPS (jednakże możliwe było osiągnięcie nawet 250 MFLOPS przy właściwie napisanym programie). Jednakże, w roku 1982 maszyna Cray X-MP oferowała wydajność na poziomie 800 MFLOPS. Pierwsza maszyna o wydajności 1.9 GFLOPS Cray-2 pojawiła się w roku 1985. Dla porównania dzisiejsze procesory do zastosowań domowych oferują wydajność na poziomie około 30 GFLOPS. Należy też nadmienić iż wydajność numeryczna kart graficznych w roku 2009/2010 sięga nawet 2.5 TFLOPS, choć dla liczb o pojedynczej precyzji.
V1.0 – 34/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Teza Churcha-Turinga oraz wypowiedź Richarda P.Feynmana
Wniosek z uwagi Feynman’a Załóżmy, że dostępna jest pewna algebra w której istnieje możliwość oszczędnej reprezentacji rejestru kwantowego e |ψ1 i e |ψ2 i e ... e |ψn−1 i = |ψi |ψ0 i To pełny wektor nadal zawiera wykładniczą ilość stanów. Ta sytuacja występuje także dla układów bez splątania, gdzie można zapamiętać stan oraz przetwarzać rejestr kwantowy wykonując operacje oddzielnie dla każdego qubitu, w czasie wielominaowym i stosować przetwarzanie w czasie równoległym. Informacja ta jest potrzebna aby np.: zrealizować operację pomiaru. Z tego powodu jest raczej mało prawdopodobne, czy być może niemożliwe, aby w przyszłości udało się utworzyć efektywny symulator obliczeń kwantowy na komputerze klasycznym.
V1.0 – 35/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Modele obliczeniowe
Modele obliczeniowe
Podobnie jak w klasycznej informatyce również w informatyce kwantowej można przedstawić kilka podstawowych schematów (modeli) obliczeń: kwantowa maszyna Turinga unitarny schemat obliczeń – odwracalne obwody kwantowe (operacja pomiar zazwyczaj jest ostatnim krokiem obliczeniowym) nieunitarny schemat obliczeń – nieodwracalne obwody kwantowe model 1WQC – jednokierunkowy model obliczeń, gdzie pomiar to główna operacja obliczeniowa, schemat obliczeń adiabatycznych
V1.0 – 36/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Modele obliczeniowe
Obliczenia kwantowe – możliwość symulacji
Stany kwantowe w opisie macierzowym i wektorowym wymagają ogromnych ilości pamięci. Zakładając, że chcemy symulować układ złożony ze stu qubitow potrzebujemy macierz i dwa równe sobie wektory stany. Chcemy przeprowadzić taką oto trywialną operację:
Ux = y
(1)
Macierz U posiada wymiary 2100 × 2100 co oznacza, że potrzebujemy „tylko”: (2100 · 2100 ) · 2 · 8 = = 25711008708143844408671393477458601640355247900524685364822016 bajtów pamięci. Obliczenia całkowitej ilości pamięci oraz czasu działania są tak ogromne iż zostaną tu pominięte, choć naturalnie asympotycznie takie same jak wymiary macierzy U.
V1.0 – 37/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Qubit, rejestry, bramki, obwody
Podstawowe własności informatyki kwantowej (naturalnie nie wszystkie): 1
superpozycja stanów
2
stany splątane
3
twierdzenie o nie usuwaniu i nie klonowaniu nieznanych stanów kwantowych
4
teleportacja kwantowa
5
supergęste upakowanie danych
6
operacja pomiaru
V1.0 – 38/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Qubit, qudit, rejestr kwantowy
Qubit – Quantum bit
Kwantowym odpowiednikiem bitu klasycznego jest qubit, a jest to układ kwantowy o dwóch wyróżnionych stanach np.: dwa poziomy atomu, spin połówkowy: {| ↑i, | ↓i}
foton o dwóch wzajemnie ortogonalnych stanach polaryzacji: {| ↑i, | →i} i można podać wiele innych przykładów.
Analogicznie do klasycznego bitu, stany {0, 1}, dwa stany qubitu wolno określać jako {|0i, |1i} i jest to tzw. baza obliczeniowa, ale częściej spotykane jest określenie baza standardowa.
V1.0 – 39/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Qubit, qudit, rejestr kwantowy
Qubit – Quantum bit – bardziej formalnie
Zero i jedynka jako wektory, czyli baza obliczeniowa: 1 0 |0i = , |1i = 0 1 Reprezentację qubitu wyznaczają nam następujące przekształcenia: 1 0 α 0 α |ψi = α|0i + β|1i = α +β = + = 0 1 0 β β | {z }
reprezentacja qubitu
2
2
gdzie α, β ∈ C oraz |α| + |β| = 1.
V1.0 – 40/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Qubit, qudit, rejestr kwantowy
Qubit – Quantum bit – bardziej formalnie Qubit, to system kwantowo-mechaniczny, który może znajdować się w stanie |0i albo |1i (będące też baza obliczeniową) bądź w dowolnej wypukłej kombinacji (liniowej kombinacji) tych dwóch stanów: |ψi = α|0i + β|1i, gdzie |α2 | + |β 2 | = 1 a także α, β ∈ C. Jeśli, wyróżnia się dwa stany, to można wyróżnić trzy stany bazowe, |0i, |1i, |2i, a tak powstały stan to qutrit: |φi = α|0i + β|1i + γ|2i, gdzie |α2 | + |β 2 | + |γ 2 | = 1 i podobnie jak poprzednio α, β, γ ∈ C. Ogólnie, oprócz qubitu, można wskazać qudit, czyli jednostkę informacji kwantowej o d stanach: ! d−1 X 2 |φi = α0 |0i + α1 |1i + . . . + αd−1 |d − 1i, gdzie |αi | = 1 i=0
i naturalnie αi , ∈ C dla i = 0, 1, 2, . . . , d − 1.
V1.0 – 41/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Qubit, qudit, rejestr kwantowy
Qudit – uogólniona jednostka informacji kwantowej Ogólna definicja stanu quditu (czyli jednostki informacji kwantowej o d podstawowych poziomach) jest następująca: |ψi = α0 |0i + α1 |1i + . . . + αd−1 |d − 1i = α0
1 0 .. .
+ α1
0
0 1 .. .
+ . . . + αd−1
0
0 0 .. .
=
1 |
α0 α1 .. .
αd−1 {z }
reprezentacja quditu
gdzie αi ∈ C oraz
P
i
2
|αi | = 1. V1.0 – 42/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Qubit, qudit, rejestr kwantowy
Rejestr kwantowy
Podobnie jak w klasycznym przypadku, gdzie połączenie kilkunastu bitów tworzy rejestr, połączenie n qubitów/quditów tworzy rejestr kwantowy: |Ψi = |ψ0 i ⊗ |ψ1 i ⊗ . . . ⊗ |ψn−1 i można rozważać taki rejestr, gdzie każdy z quditów ma różną liczbę stanów bazowych. Jednak, w większości przypadków zakłada się, że w rejestrze wszystkie qudity są tego samego stopnia, tzn. mają taką samą liczbę stanów bazowych. Rozpatrujemy układ o trzech qubitach: |ψi = |q0 q1 q2 i
V1.0 – 43/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Qubit, qudit, rejestr kwantowy
Rejestr kwantowy Przekształcenia są następujące:
α1 α 0 β1 α0 α1 α2 α2 |q0 q1 q2 i = ⊗ ⊗ = ⊗ β2 = β0 β1 β2 α1 β0 β1 α0 α1 α0 β1 α 2 = β0 α1 ⊗ β2 = β0 β1
α0 α1 α2 α0 α1 β2 α0 β1 α2 α0 β1 β2 β0 α1 α2 β0 α1 β2 β0 β1 α2 β0 β1 β2
α0 000 α1 001 α2 010 7 X α3 011 gdzie |αi |2 = 1 ' 100 α4 i=0 α5 101 α6 110 α7 111 V1.0 – 44/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Qubit, qudit, rejestr kwantowy
Ważne jest ustalenie zasad posługiwania się rejestrem np.: 1
qubity numerujemy od zera do n − 1, czyli zerowy qubit znajduje się po lewej stronie
stany klasyczne odczytujemy od prawej strony, traktując prawy najbardziej zewnętrzny bit jako najmniej znaczący Stan |011i reprezentuje sobą wartość: trzy. 0 0 0 1 |011i = 0 0 0 0 2
V1.0 – 45/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Qubit, qudit, rejestr kwantowy
Wektorowe reprezentacje stanów kwantowych Przykładowe stany qubitu o nazwach odpowiednio: zero 1 |0i = 0
jeden 0 |1i = 1
dodatnia superpozycja " # |+i =
√1 2 √1 2
Stany maksymalnie splątane: 1 |ψi = √ (|00i + |11i) = 2
√ 1/ 2 0 0 √ 1/ 2
1 , |ψi = √ (|01i + |10i) = 2
0 √ 1/√2 1/ 2 0
Stany splątane przydatne np.: do realizacji teleportacji probabilistycznej: √ 1 2 |ψi = ( √ |00i + √ |11i) = 3 3
√ 1/ 3 0 √ 0√ 2/ 3
√ 2 1 , |ψi = ( √ |00i + √ |11i) = 3 3
√
√ 2/ 3 0 0 √ 1/ 3
V1.0 – 46/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Qubit, qudit, rejestr kwantowy
Macierz gęstości Macierz gęstości nieznanego czystego stanu qubitu |ψi jest określona w następujący sposób: 2 α αβ (2) ρ = |ψihψ| = 2 αβ β gdzie wektor hψ| reprezentuje transponowany wektor |ψi. Reprezentacja dla macierzy gęstości stanu mieszanego składającego się ze stanów czystych |ψi i jest następująca X ρ= λi |ψi ihψi |, (3) i
gdzie λi określa prawdopodobieństwo wystąpienia stanu |ψi i oraz
P
i
λi = 1.
Wykładniczy wzrost danych kwantowych Rozmiar rejestru kwantowego opisanego przez wektor stanu to 2n bądź d n gdzie n to ilość qubitów/quditów, a d to stopień quditu. Natomiast wymiary macierzy gęstości to d n × d n . Wektor stanu dla 16 qubitów wymaga 512kb pamięci, macierz gęstości 256MB jeśli stosowana jest liczba pojedynczej precyzji. Dla 32 qubitów wektor stanu wymaga 32GB dostępnej pamięci, natomiast macierz gęstości 1 ZB (zetta bytes).
V1.0 – 47/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Bramki kwantowe
Operacje na jednym qubicie – bramka jednoqubitowa Najważniejsze bramki jednoqubitowe: 0 1 0 −i 1 0 σx = X = σy = Y = σz = Z = i 0 0 −1 1 0 1 0 1 1 1 0 π 1 √ π S= H= 2 8 = 1 −1 0 i 0 ei 4 Uwaga o bramkach jednoqubitowych Wymienione bramki powodują obrót qubitu. Uogólniając (twierdzenie Blocha, o operatorach unitarnych), każdą bramkę o wymiarach 2 × 2 przedstawiamy jako (α, β, δ, θ ∈ R): U(·) =
e iδ 0
0 e iδ
!
e iα/2 0
0 e −iα/2
!
cos θ/2 − sin θ/2
sin θ/2 cos θ/2
e iβ/2 0
0 e −iβ/2
!
V1.0 – 48/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Bramki kwantowe
Bramka obrotu, gdzie parametrami są kąty Eulera
Obroty wokół osi X lub Y bądź Z: θ
cos θ2 i sin θ2 θ θ i sin 2θ cos 2θ cos 2 sin 2 = θ θ − sin cos 2 " θ #2 i2 e 0 = θ 0 e −i 2
Rx (θ) = e iσx 2 = θ
Ry (θ) = e iσy 2 θ
Rz (θ) = e iσz 2
Bramka U U = Rz (α)Ry (β)Rz (γ) α, β, γ ∈ R
V1.0 – 49/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Bramki kwantowe
Operacje na jednym qudicie – bramka jednoquditowa Niech ω oznacza prymitywny pierwiastek z jedności stopnia d, czyli ω d = 1, a poszczególne pierwiastki są określone jako: 2πik 2kπ 2kπ k ωd = cos + i sin = e d , k = 0, 1, 2, . . . , d − 1 d d Podstawowe bramki dla quditów są określone w następujący sposób: X |ji = |j + 1 mod di j
Z |ji = ω |ji
P|ji = ω H|ji =
j(j−1)/2
d−1 X k=0
bramka negacji bramka zmiany znaku
|ji
bramka zmiany fazy
ω j·k |ki
bramka Hadamarda
V1.0 – 50/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Bramki kwantowe
Bramki kwantowe – bramka Hadamarda Reprezentacja macierzowa bramki Hadamarda (bramka H): 1 1 1 H= √ 1 −1 2 Podstawowe stany |0i oraz |1i są przekształcane przez bramkę Hadamarda w następujący sposób: |0i + |1i |0i − |1i √ √ H|0i = , H|1i = 2 2 Jednak H
H
|0i+|1i √ 2
|0i + |1i |0i |1i √ = H√ +H√ = 2 2 2
I podobnie H
H
= |0i:
|0i−|1i √ 2
|0i+|1i √ 2
√
2
+
|0i−|1i √ 2
√
2
=
1 (|0i + |1i + |0i − |1i) = |0i 2
=
1 (|0i + |1i − |0i + |1i) = |1i 2
= |1i:
|0i − |1i |0i |1i √ = H√ −H√ = 2 2 2
|0i+|1i √ 2
√
2
−
|0i−|1i √ 2
√
2
V1.0 – 51/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Bramki kwantowe
Chcemy wykonać operację: U ⊗ I ⊗ I . U I I Otrzymujemy następującą macierz: α0 α1 α2 α . . α0 α1 β2 . α . α0 β1 α2 . . α α0 β1 β2 . . . β0 α1 α2 γ . . β0 α1 β2 . γ . β0 β1 α 2 . . γ . . . β0 β1 β 2
. . . α . . . γ
β . . . δ . . .
. β . . . δ . .
. . β . . . δ .
. . . β . . . δ
000 001 010 011 100 101 110 111
V1.0 – 52/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Bramki kwantowe
Chcemy wykonać operację: I ⊗ U ⊗ I . I U I Otrzymujemy następującą macierz: α0 α1 α2 α . β α0 α1 β2 . α . α0 β1 α2 γ . δ α0 β1 β2 . γ . β0 α1 α2 . . . β0 α1 β2 . . . β0 β1 α 2 . . . . . . β0 β1 β 2
. β . δ . . . .
. . . . α . γ .
. . . . . α . γ
. . . . β . δ .
. . . . . β . δ
000 001 010 011 100 101 110 111
V1.0 – 53/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Bramki kwantowe
Tym razem chcemy wykonać operację: I ⊗ I ⊗ U. I I U Otrzymujemy następującą macierz: α0 α1 α2 α β . α0 α1 β2 γ δ . α0 β1 α2 . . α α0 β1 β2 . . γ β0 α1 α2 . . . β0 α1 β2 . . . β0 β1 α 2 . . . . . . β0 β1 β 2
. . β δ . . . .
. . . . α γ . .
. . . . β δ . .
. . . . . . α γ
. . . . . . β δ
000 001 010 011 100 101 110 111
V1.0 – 54/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Bramki kwantowe
Bramki dwu oraz trzyqubitowe
Bramka CNOT •
|ai |bi
1 0 CNOT = 0 0
0 1 0 0
Bramka Toffoli
|ai
|ai
•
|ai
|a ⊕ bi
|bi
•
|bi
0 0 0 1
0 0 1 0
|ci
Toffoli =
|c ⊕ abi
I I
X
Bramki wieloqubitowe powstają dzięki sumie prostej np.: Toffoli = I ⊕ I ⊕ X .
V1.0 – 55/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Bramki kwantowe
Bramki kwantowe – CNOT
Działanie bramki CNOT: CNOT (1) (|00i) = |00i CNOT (1) (|01i) = |01i , CNOT (1) (|10i) = |11i CNOT (1) (|11i) = |10i
CNOT (0) (|00i) = |01i CNOT (0) (|01i) = |00i CNOT (0) (|10i) = |10i CNOT (0) (|11i) = |11i
Macierzowa reprezentacja CNOT:
CNOT(1)
1 0 = 0 0
0 1 0 0
0 0 0 1
0 0 , 1 0
CNOT(0)
0 1 = 0 0
1 0 0 0
0 0 1 0
0 0 0 1
V1.0 – 56/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Bramki kwantowe
Bramki dwu oraz trzyqubitowe
W przypadku tworzenia macierzy operacji U dla bramek 2, 3 i więcej qubitowych nie możemy stosować iloczynu tensorowego: Obwód
• U
1 . . . . . . .
. 1 . . . . . .
. . 1 . . . . .
Macierz U . . . . . . . . . . . . 1 . . . . α . β . . α . . γ . δ . . γ .
. . . . . β . δ
000 001 010 011 100 101 110 111
V1.0 – 57/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Bramki kwantowe
Bramki Toffoliego Bramka kontrolowanej negacji może posiadać więcej linii sterującej niż tylko jedną. Bramka Toffoli jest przykładem bramki kontrolowanej negacji. Reprezentacja macierzowa jest następująca, 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 I 0 0 0 1 0 0 0 0 I = Toffoli = 0 0 0 0 1 0 0 0 X 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 Zapis działania bramki Toffoli na stanach bazowych jest następujący Toffoli|000i = |000i Toffoli|010i = |010i Toffoli|100i = |100i Toffoli|110i = |111i
Toffoli|001i = |001i Toffoli|011i = |011i . Toffoli|101i = |101i Toffoli|111i = |110i
V1.0 – 58/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Bramki kwantowe
Bramki Toffoliego Graficznie bramkę Toffoliego zwykło przedstawiać się na dwa podstawowe sposoby:
|xi
|xi
|xi
|xi
|yi
|yi
|yi
|yi
|xy ⊕ zi
|zi
|xy ⊕ zi
|zi
X
(a)
(b)
.
V1.0 – 59/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Bramki kwantowe
Uniwersalna bramka Deutscha
D(θ) : |i, j, ki =
i cos(θ)|i, j, ki + sin(θ)|i, j, 1 − ki for i = j = 1 |i, j, ki otherwise
Gdy D( π2 ) to bramka D redukuje się do bramki Toffoli’ego, która pozwala na realizację dowolnego logicznego układu klasycznego.
V1.0 – 60/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Operacja pomiaru
Realizacja pomiaru von Neumanna Niech |ψm i będzie bazą w której realizowany jest pomiar. Operator projekcji Pm określamy w następujący sposób: X Pm = I Pm = |ψm ihψm | oraz Pm Pm0 = δm,m0 Pm naturalnie m
Nowy otrzymany stan po pomiarze przyjmuje postać: 0 Pm |ψi |ψ i = √ . pm
a prawdopodobieństwo jego otrzymania to pm = hψ|Pm |ψi. Baza standardowa jest określona na następujących projektorach: P0 = |0ih0|, P1 = |1ih1|. Stosowane są także inne definicje bazy np.: baza w tzw. modelu jednokierunkowym jest określona jako: |0i + e iϕ |1i |0i − e iϕ |1i √ √ B(ϕ) = , 2 2 V1.0 – 61/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Operacja pomiaru
Przykład ogólnej operacji pomiaru Kwantowy pomiar jest opisany przez zbiór operatorów pomiaru {Mi }. Operatory Mi działają w przestrzeni stanu mierzonego systemu. Zastosowany indeks i odnosi do rezultatu przeprowadzonej operacji pomiaru. Jeśli stan układu określimy jako |ψi, to prawdopodobieństwo tego iż w wyniku operacji pomiaru otrzymamy rezultat odnoszący do indeksu i jest określona jako p(i) = hψ|Mi† Mi |ψi. Stan systemu po wykonaniu operacji pomiaru jest następujący Mi |ψi q . hψ|Mi† Mi |ψi P Zbiór operatorów pomiaru {Mi } spełnia również relację zupełności i Mi† Mi = I.Zupełność operatorów pomiaru oznacza iż prawdopodobieństwa poszczególnych rezultatów sumują się do jedności X X 1= p(i) = hψ|Mi† Mi |ψi. i
i V1.0 – 62/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Operacja pomiaru
Przykład ogólnej operacji pomiaru Zastosowanie operacji pomiaru warto poprzeć nieskomplikowanym przykładem np.: dla quditu o d = 3, o stanie |ψi = α0 |0i + α1 |1i + α2 |2i. W tym przypadku przygotowujemy następujący zbiór operatorów: M0 = |0ih0|, M1 = |1ih1|, M2 = |2ih2|
(4)
Wszystkie operatory pomiaru są operatorami hermitowskimi oraz M02 = M0 , M12 = M1 , M22 = M2 , co oznacza: I = M0† M0 + M1† M1 + M2† M2 = M0 + M1 + M2 ,
(5)
czyli, relacja zupełności jest spełniona. Poszczególne prawdopodobieństwa dla możliwych rezultatów pomiaru są następujące: p(0) = hψ|M0† M0 |ψi = hψ|M0 |ψi = |α0 |2 , p(1) = hψ|M1† M1 |ψi = hψ|M1 |ψi = |α1 |2 , p(2) = hψ|M2† M2 |ψi = hψ|M2 |ψi = |α2 |2 .
(6) V1.0 – 63/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Operacja pomiaru
Przykład ogólnej operacji pomiaru
Stan po wykonaniu pomiaru może przyjąć trzy możliwe postaci: M0 |ψi α0 = |0i, |α0 | |α0 | M1 |ψi α1 = |1i, |α1 | |α1 | M2 |ψi α2 = |2i. |α2 | |α2 |
(7)
Możliwe stany jakie można otrzymać po wykonaniu pomiaru, to stany |0i, |1i, |2i, gdyż jeden ze współczynników α0 |α0 |, α1 |α1 |, α2 |α2 | po wykonaniu pomiaru, przyjmie wartość równą jedności.
V1.0 – 64/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Uniwersalne zbiory bramek
Uniwersalne zbiory bramek
Kolekcja jednoquditowych bramek Ai oraz dwuquditowych Bj jest określona jako (dokładnie) uniwersalna jeśli, dla każdego n ≥ 2, każdą n-quditową bramkę można (przybliżyć z dowolną dokładnością|wyrazić dokładnie) poprzez utworzenie obwodu zbudowanego z bramek Ai oraz Bj . Twierdzenie o zbiorze uniwersalnym dla qubitów (A.Barenco i inni (quantph/9503016)) : Zbiór uniwersalny dla qubitów Używając jedynie bramek sterowanej negacji oraz bramek unarnych, można zbudować dowolny obwód kwantowy.
V1.0 – 65/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Uniwersalne zbiory bramek
Twierdzenie Jean-Luc’a Brynlinski’ego oraz Ranee Brynlinski’ej dla quditów d ≥ 2: Zbiór uniwersalny dla quditów Zakładając iż mamy dwuquditową bramkę V , zachodzą następujące własności: (i) kolekcja wszystkich bramek 1-quditowych oraz bramka V są uniwersalne, (ii) kolekcja wszystkich bramek 1-quditowych oraz bramka V są dokładnie uniwersalne, (iii) bramka V jest nie prymitywna.
V1.0 – 66/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Uniwersalne zbiory bramek
Twierdzenie Solovaya-Kitaeva
Tw. Solovaya-Kitaeva Niech S oznacza skończony zbiór bramek unarnych, które pozwalają przybliżyć każdą unarną bramkę kwantową z dowolną dokładnością. Wtedy istnieje stała C , zależna od S, oraz c ≈ 4, takie że działanie każdej unitarnej bramki można przybliżyć z dokładnością ε przy użyciu co najwyżej C logc 1ε bramek ze zbioru S.
Wniosek jaki można wyciągnąć z powyższego twierdzenia jest następujący: działanie obwodu kwantowego, składającego się z n bramek, można symulować przy użyciu O(n logc nε ) bramek ze zbioru uniwersalnego, z zadaną dokładnością reprezentowaną przez ε.
V1.0 – 67/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Twierdzenie o nie-klonowaniu stanów kwantowych
Twierdzenie o nie-klonowaniu stanów kwantowych
Twierdzenie o nie-klonowaniu stanów kwantowych Woottersa i Żurka [W.K. Wootters and W.H. Zurek, Nature, 299:802–803, 1982]. Rozważamy układ kwantowy o n stanach bazowych |a1 i, ..., |an i, gdzie na stan |a1 i chcemy przenieść dowolny inny stan. Unitarne odwzorowanie w przestrzeni Hn ⊗ Hn nazywamy kwantową maszyną kopiującą, jeżeli dla dowolnego stanu |ψi ∈ Hn zachodzi: U(|ψi|a1 i) = |ψi|ψi. (8) Twierdzenie Woottersa i Żurka Dla n > 1 kwantowa maszyna kopiująca nie istnieje.
V1.0 – 68/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Twierdzenie o nie-klonowaniu stanów kwantowych
Twierdzenie o nie-klonowaniu stanów kwantowych Dowód: Dowód twierdzenia rozpoczyna się następująco: zakłada się, że maszyna kopiująca istnieje. Ponieważ n > 1, to istnieją przynajmniej dwa stany ortogonalne |a1 i i |a2 i. Wobec czego: U(|a1 i|a1 i) = |a1 i|a1 i oraz dla drugiego stanu: U(|a2 i|a1 i) = |a2 i|a2 i, ponadto: U
1 1 1 √ (|a1 i + |a2 i)|a1 i = √ (|a1 i + |a2 i) √ (|a1 i + |a2 i) = 2 2 2 1 = (|a1 i|a1 i + |a1 i|a2 i + |a2 i|a1 i + |a2 i|a2 i) 2
(9)
Jednak wykorzystując liniowość U możemy podać następujące przekształcenia: U
1 √ (|a1 i + |a2 i)|a1 i = 2 1 1 1 1 √ U(|a1 i|a1 i) + √ U(|a2 i|a1 i) = √ |a1 i|a1 i) + √ |a2 i|a2 i 2 2 2 2
(10)
Niestety, obydwie reprezentacje stanu nie są takie same, toteż otrzymano sprzeczność, co ostatecznie pozwala podsumować dowód. V1.0 – 69/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Obwody kwantowe
Obwód do detekcji stanów uogólnionych stanów Bell’a
Dowolna para Bella dla dwóch quditów o d-poziomach jest określona przez następujące równanie d−1 1 X 2πıjp/d d |ψpq i= √ e |ji|(j + q) mod di. d j=0
Powyższe równanie posiada odpowiednik w postaci równania wyrażonego za pomocą bramek kwantowych, q
p
d |ψpq i = (Id ⊗ Xd ) · (Hd ⊗ Id ) · (Zd ⊗ Id ) · CNOTd · |00i.
V1.0 – 70/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Obwody kwantowe
Obwód do detekcji stanów uogólnionych stanów Bell’a
X |ψpq i
|ψpq i X
|0i |0i
H
H†
M0 X†
X
M1
V1.0 – 71/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Obwody kwantowe
Obwód zrealizowany w postaci skryptu import qcs import math _D_LEVEL = 4; def make_psi(_r,p,q): _r.Reset() for i in range(0,q): _r.NotN(1) _r.HadN(0) for i in range(0,p): _r.PauliZ(0) _r.CNot(0,1)
def detect_bell_state( _r ): _r.HadN(2) _r.CNot(2,0) _r.CNot(2,1) _r.HadN_Conj(2) a1=_r.MeasureOneQudit(2) _r.CNot_Conj(0,3) _r.CNot(1,3) a2=_r.MeasureOneQudit(3) return a1,a2
print "d-level psi state" r.Pr() a1,a2=detect_bell_state(r) print ą1="+str(a1) print ą2="+str(a2) r.Pr()
r=qcs.QuantumReg( 4, _D_LEVEL ) r.Reset() make_psi(r,1,3)
Dla par Bella dla qubitów, tabela możliwych wyników jest następująca |ψ + i |φ+ i |ψ − i |φ− i
√1 2 √1 2 √1 2 √1 2
(|00i + |11i) (|01i + |10i) (|00i − |11i) (|01i − |10i)
00 01 10 11
V1.0 – 72/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Obwody kwantowe
Obwód zrealizowany w postaci skryptu Możliwe jest do pokazania iż pierwsza liczba będąca wynikiem pierwszego pomiaru wskazuje na znak w parze, natomiast druga liczba opisuje przesunięcie w stanach bazowych. Wyniki dla par Bella zbudowanych z quditów o stopniu d = 3, |ψ 0 i |ψ 1 i |ψ 2 i |φ0 i 1
|φ i 2
|φ i |ϕ0 i 1
|ϕ i 2
|ϕ i
1 √ 3 1 √ 3 1 √ 3 √1 3 √1 3 √1 3
√1 3 √1 3 √1 3
(|00i + |11i + |22i) (|01i + |12i + |20i) (|02i + |10i + |21i)
|00i + e
2iπ 3
|01i + e
2iπ 3
|02i + e
2iπ 3
|00i + e
4iπ 3
|01i + e
4iπ 3
|02i + e
4iπ 3
|11i + e
4iπ 3
|12i + e
4iπ 3
|10i + e
4iπ 3
|11i + e
8iπ 3
|12i + e
8iπ 3
|10i + e
8iπ 3
00 01 02
|22i
10
|20i
11
|21i
12
|22i
20
|20i
21
|21i
22
.
Jak widać pierwsza wartość decyduje o postaci amplitudy, a dokładniej o jej fazie, natomiast drugi rezultat wskazuje na postać stanów bazowych. Zaobserwowane zależności naturalnie są konsekwencją definicji uogólnionej pary splątanej. V1.0 – 73/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Kwantowa teleportacja deterministyczna
Teleportacja stanu kwantowego
V1.0 – 74/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Kwantowa teleportacja deterministyczna
Teleportacja stanu kwantowego – poprawność arytmetyczna Stan początkowy układu trzech qubitów wraz z teleportowanym stanem posiadanym przez Alicję (qubit pierwszy) przedstawia się następująco: a a b b √ |000i + √ |011i + √ |100i + √ |111i. 2 2 2 2 Następnym krokiem jest utworzenia splątania pomiędzy qubitem teleportowanym a qubitem o numerze dwa za pomocą bramki CNOT. W efekcie otrzymamy następujący stan: a b b a √ |000i + √ |011i + √ |110i + √ |101i 2 2 2 2 Po utworzeniu splątania Alicja przekształca stan qubitu o numerze jeden za pomocą bramki Hadamarda, nowo otrzymany stan przedstawia się następująco: a 1 a 1 √ √ (|0i + |1i)|00i + √ √ (|0i + |1i)|11i+ 2 2 2 2 b 1 b 1 √ √ (|0i − |1i)|10i + √ √ (|0i − |1i)|01i. 2 2 2 2 V1.0 – 75/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Kwantowa teleportacja deterministyczna
Teleportacja stanu kwantowego – poprawność arytmetyczna Po wykonaniu niezbędnych przekształceń i uproszczeń można zapisać ów stan w następujący sposób, aby określić jawnie stan trzeciego qubitu będącego w posiadaniu Bob’a: 1 |00i(a|0i + b|1i) + 2 1 |10i(a|0i − b|1i) + 2
1 |01i(a|1i + b|0i) 2 1 |11i(a|1i − b|0i) 2
Przedostatnim krokiem jest wykonanie przez Alicje pomiaru na dwóch pierwszych qubitach (które znajdują się w jej posiadaniu). Może ona uzyskać cztery wyniki 00, 01, 10, 11 każdy z tym samym prawdopodobieństwem równym 0.25. Stan układu w zależności od wyników pomiaru przedstawia tabela o następującej postaci: Wynik pomiaru 00 01 10 11
Stan |00i(a|0i + b|1i) |01i(a|1i + b|0i) |10i(a|0i − b|1i) |11i(a|1i − b|0i) V1.0 – 76/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Kwantowa teleportacja deterministyczna
Teleportacja stanu kwantowego – poprawność arytmetyczna
Po realizacji pomiaru przez Alicję, wyniki pomiaru są przesyłane do Boba, który w zależności od otrzymanych wartości koryguje stan trzeciego qubitu w następujący sposób: 1
jeśli Bob otrzymał wartość 00, to stan trzeciego qubitu jest poprawny i nie trzeba wykonywać dodatkowych operacji,
2
jeśli wynikiem pomiaru jest 01, to amplitudy prawdopodobieństwa są zamienione miejscami i Bob wykonuje operację negacji na swoim qubicie, aby przywrócić poprawny układ,
3
jeśli otrzymany rezultat pomiaru wynosi 10, to Bob aby zrekonstruować stan teleportowany przez Alicję musi wykonać operację zmiany znaku,
4
w ostatnim przypadku rezultat to 11, oznacza iż trzeba wykonać dwie operacje, negację oraz zmianę znaku.
V1.0 – 77/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Kwantowa teleportacja deterministyczna
Teleportacja stanu kwantowego
|ψi |0i |0i
H AM
H
|0i . . . |d − 1i
X X
BM
V1.0 – 78/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Kwantowa teleportacja deterministyczna
Teleportacja stanu kwantowego – qubit
Teleportacja jako skrypt dla Pythona oraz QCS import qcs
_TELEPORT_QUBIT = 0 _ALICE_QUBIT = 1 _BOB_QUBIT = 2 q=qcs.QubitReg(3) q.Reset() q.SetKet("000") q.HadN(_TELEPORT_QUBIT) q.HadN(_ALICE_QUBIT) q.CNot(_ALICE_QUBIT, =⇒ _BOB_QUBIT) q.CNot(_TELEPORT_QUBIT, =⇒ _ALICE_QUBIT) q.HadN(_TELEPORT_QUBIT)
v=q.MeasureN(_TELEPORT_QUBIT, _ALICE_QUBIT) if v==0: q.Pr() if v==1: q.NotN(_BOB_QUBIT) q.Pr() if v==2: q.PhaseFN(_BOB_QUBIT) q.Pr() if v==3: q.NotN(_BOB_QUBIT) q.PhaseFN(_BOB_QUBIT) q.Pr() del q
V1.0 – 79/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Kwantowa teleportacja deterministyczna
Teleportacja stanu kwantowego – qudit
Teleportacja jako skrypt dla Pythona oraz QCS import qcs import math
q.HadN(_ALICE_QUDIT) q.CNot(_ALICE_QUDIT, _BOB_QUDIT)
_D_LEVEL = 4
q.CNot(_TELEPORT_QUDIT, _ALICE_QUDIT) q.HadN(_TELEPORT_QUDIT)
_TELEPORT_QUDIT = 0 _ALICE_QUDIT = 1 _BOB_QUDIT = 2
v1=q.MeasureOneQudit( _TELEPORT_QUDIT ) v2=q.MeasureOneQudit( _ALICE_QUDIT )
q=qcs.QuantumReg(3, _D_LEVEL) q.Reset()
mat = q.CorrMatForTeleport(v1, v2) q.ArbitrarySingleGate( _BOB_QUDIT, mat);
q.NotN(_TELEPORT_QUDIT) q.HadN(_TELEPORT_QUDIT)
print "teleported state" q.Pr()
print "teleported state" q.Pr()
del q
V1.0 – 80/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Algorytm Deutscha–Jozsy
Algorytm Deutscha–Jozsy
Dany jest obwód (czarna skrzynka) obliczający funkcje f : {0, 1}n → {0, 1}. Funkcja f jest albo stała (0 bądź 1 dla wszystkich stanów na wejściu), albo zrównoważona (wyniki 0 dla połowy stanów wejściowych oraz wyniki 1 na połowie). Zadanie jest następujące: określić, czy f jest stała czy zrównoważona przy pomocy obwodu. Deterministyczny algorytm dla n bitów wejściowych wymaga 2n−1 obliczeń funkcji f w najgorszym przypadku. Dodatkowo aby udowodnić, że f jest stała, potrzeba ja obliczyć dla ponad połowy stanów wejściowych obwodu.
V1.0 – 81/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Algorytm Deutscha–Jozsy
Algorytm Deutscha–Jozsy
Algorytm Deutscha jest modyfikacja obwodu obliczającego równolegle wartości funkcji f : {0, 1} → {0, 1}, łączącym własności kwantowej równoległość z wykorzystaniem interferencji oraz superpozycji stanów wejściowych. Obwód kwantowych dla n = 1 realizujący alg. Deutscha–Jozsy:
|0i
H
|1i
H
H Uf
V1.0 – 82/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Algorytm Deutscha–Jozsy
Algorytm Deutscha–Jozsy – analiza Po bramce H ⊗2 :
|0i + |1i √ 2
⊗
|0i − |1i √ 2
Po obliczeniach Uf : |0i−|1i ± |0i+|1i √ √ ⊗ , f (0) = f (1) 2 2 |0i−|1i |0i−|1i ± √ √ ⊗ , f (0) 6= f (1) 2 2 Po bramce H:
±|0i ⊗ |0i−|1i √ , f (0) = f (1) 2 ±|1i ⊗ |0i−|1i √ , f (0) 6= f (1) 2
V1.0 – 83/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Algorytm Deutscha–Jozsy
Algorytm Deutscha–Jozsy – wnioski końcowe
Z założenia wiadomo, że f (0) ⊕ f (1) jest 0, gdy f (0) = f (1) i 1 w przeciwnym przypadku, toteż końcowy stan mozna zapisać: |0i − |1i √ . ±|f (0) ⊕ f (1)i ⊗ 2 Co oznacza iż f (0) ⊕ f (1) = 0 (czyli funkcja jest stała) wtedy i tylko wtedy, gdy wynikiem pomiaru jest 0. Ten algorytm jest deterministyczny oraz wystarczyło tylko raz wywołać obliczenia Uf .
V1.0 – 84/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Algorytm Deutscha–Jozsy
Algorytm Deutscha–Jozsy – wersja dla n
Uogólniona odmiana obwodu do realizacji alg. Deutscha–Jozsy dla n bitów:
|0i⊗n |1i
H ⊗n
H ⊗n Uf
H
V1.0 – 85/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Algorytm Deutscha–Jozsy
Algorytm Deutscha–Jozsy – analiza Stan początkowy: |0i⊗n ⊗ |1i
Po bramakach H ⊗(n+1) 1 √ 2n
X x∈{0,1}n
|xi ⊗
|0i − |1i √ 2
Po obliczeniu Uf 1 √ 2n
X x∈{0,1}n
f (x)
(−1)
|xi ⊗
|0i − |1i √ 2
P (x·z) Wykorzystując fakt H ⊗n |xi = √12n z∈{0,1}n (−1) |zi, (x · z ≡ x1 z1 ⊕ . . . ⊕ xn zn ), to stan końcowy przyjmuje postać: X |0i − |1i 1 X x·z+f (x) √ (−1) |xi ⊗ . 2n 2 x∈{0,1}n z∈{0,1}n V1.0 – 86/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
Algorytm Deutscha–Jozsy
Algorytm Deutscha–Jozsy – wnioski końcowe
Prawdopodobieństwo zmierzenia stanu |0i⊗n jest określony jako 1 2n
X x∈{0,1}n
2
f (x)
(−1)
.
Jeżeli badana funkcja f jest stała, to prawdopodobieństwo otrzymania stanu |0i⊗n jest równe jedności. Natomiast, jeżeli f jest zrównoważona, to prawdopodobieństwo uzyskania tego stanu jest równe zero, czyli zmierzona będzie inna wartość. Ponownie wystarczyło jedno wywołanie Uf .
V1.0 – 87/ 88
Wprowadzenie Algorytmy randomizowane
Obliczenia kwantowe
W następnym tygodniu między innymi
1
Algorytm Grovera
2
Algorytm Shora
3
Algorytm BB84 – kryptografia kwantowa
4
Inne protokoły kwantowej dystrybucji klucza
5
Protokołu transferu stanów kwantowych
6
Kwantowa maszyna Turinga
7
Kwantowe klasy złożoności
Dziękuje za uwagę!!! V1.0 – 88/ 88
![notatek-pl-statystyka-podstawy-wyklady-i-czesc[1]](https://docer.tips/img/300x300/notatek-pl-statystyka-podstawy-wyklady-i-czesc1_5a9bc52ad64ab2b5210e835f.jpg)
