1 Kontrolowanie poszukiwania

2 Controlling Search u Estimating Efficiency of a CLP Program u Rule Ordering u Literal Ordering u Adding Redundant Constraints u Minimization u Identifying Deterministic Subgoals u Example: Bridge Building

3 Szacowanie efektywności u Obliczenia to przeszukiwanie w drzewie wyprowadzeń u Wielkość tego drzewa wpływa na koszt poszukiwań u gdy mniejsze to mniejszy u odpowiedź jest na lewo: mniej poszukiwania przed pierwszą odpowiedzią u Drzewo wyprowadzenia zależy od trybu użycia

4 Tryb użycia u tryb użycia: definiuje warunki, które muszą spełniać argumenty, gdy predykat jest wywoływany u fixed: z magazynu więzów da sę wywnioskować pojedyńczą wartość dla parametru u free: dopuszczalne są wszystkie wartości u możliwe inne (np. ograniczone z góry, dołu)

5 Przykład trybu użycia u tryb użycia: 1 arg. fixed drugi free u sumlist([1],S). u L=[1,2],S > Z, sumlist(L,S). u Stany w drzewie wyprowadzenia w wywołaniem sumlist u sumlist([], 0). sumlist([N|L], N+S) :- sumlist(L, S).

6 Przykład u Wyobraźmy sobie, że piszemy program obliczający u Myślimy w następujący sposób: u suma N liczb to suma N-1 i N u suma 0 liczb to 0 u Problem sum(1,S) nie daje odpowiedzi (S1) sum(N, S+N) :- sum(N-1, S). (S2) sum(0, 0).

7 Przykład Uproszczone drzewo wyprowadzeń sum(1,S)

8 Przykład u Nieskończone wyprowadzenie przed odpowiedzią u sum(1,S) da odpowiedź S=1, u a sum(1,0)? (S3) sum(0, 0). (S4) sum(N, S+N) :- sum(N-1, S).

9 Przykład u Nie planowaliśmy, by program pracował z liczbami ujemnymi. Poprawmy go. (S5) sum(0, 0). (S6) sum(N, S+N) :- sum(N-1, S), N >= 1.

10 Przykład u Przetwarzanie od lewa na prawo u sum(1,S) daje S = 1, sum(1,0) odpowiada no u metody: u zmiana porządku reguł u dodawanie więzów nadmiarowych u porządek literałów (S7) sum(0, 0). (S8) sum(N, S+N) :- N >= 1, sum(N-1, S).

11 Porządek reguł u zasada ogólna u nierekurencyjne przed rekurencyjnymi u (pozwoli to czasem uniknąć nieskończonych wyprowadzeń) u zasada heurystyczna u najpierw reguły, które wydają się częściej prowadzić do odpowiedzi u (może przesuwać w lewo drzewa szczęśliwe węzły)

12 Kolejność literałów u Więzy bazowe u więz w miejscu gdzie najwcześniej spowoduje porażkę (dla jakiegoś trybu użycia) u fac(N,F)z N ustaloną F wolną fac(N, F) :- N = 0,F = 1. fac(N, FF) :- N >= 1, FF = N * F, N1 = N - 1, fac(N1, F). fac(N, F) :- N = 0,F = 1. fac(N, FF) :- N >= 1, N1 = N - 1, fac(N1, F), FF = N * F.

13 Kolejność literałów u Więzy użytkownika: u deterministyczne przed innymi u deterministyczny: p(s1,...,sn) jest deterministyczny, jeżeli w każdym punkcie wyboru w drzewie wyprowadzeń wszyskie gałęzie (prócz jednej) kończą się podczas analizy więzów bazowych (nie użytkownika) u predykat jest deterministyczny dla danego trybu użycia

14 Predykaty deterministyczne u sumlist(L,S) jest deterministyczny, gdy L jest ustalone S wolne. Nie odwrotnie. u sum(N,S) podobnie u predykaty deterministyczne nie(?) wymagają poszukiwania do znalezienia odpowiedzi u Zmiana położenia predykatu w klauzuli może zmienić jego,,deterministyczność

15 Zmiana kolejności literałów father(jim,edward). father(jim,maggy). father(edward,peter). father(edward,helen). father(edward,kitty). father(bill,fi). mother(maggy,fi). mother(fi,lillian). father(F,C) jest deterministyczny dla C ustalonego i F wolnego, ale nie na odwrót. Podobnie mother(M,C) Każde dziecko ma jednego ojca Ojciec może mieć wiele dzieci

16 Zmiana kolejności literałów grandf(GF,GC) :- father(GF,P),father(P,GC). grandf(GF,GC) :- father(GF,P),mother(P,GC). Dla trybu użycia GC ustalony GF wolny: Jaki tryb użycia dla pierwszej wersji? father(GF,P) oba wolne, father(P,GC) oba ustalone Gdy zmienimy kolejność? father(P,GC) wolne ustalone, father(GF,P) wolne, ustalone

17 Zmiana kolejności literałów grandf(GF,GC) :- father(P,GC),father(GF,P). grandf(GF,GC) :- mother(P,GC),father(GF,P). Bardziej efektywny dla tryby wolny - ustalony grandf(X,peter) daje 63 stany w uproszczonym drzewie dla pierwszego programu a 23 dla drugiego.

18 Dodawanie więzów nadmiarowych. u Nadmiarowym nazwiemy taki więz, który można usunąć z reguły nie zmieniając odpowiedzi u więz nadmiarowy: ten sam zbiór odpowiedzi u H :- L1,..., Li, Li+1,..., Ln u H :- L1,..., Li, c, Li+1,..., Ln u korzyści u zawodzi, ale nie

19 Dodawanie więzów nadmiarowych. Więz N >= 1 dodany do programu na sumę był nadmiarowy (ze względu na odpowiedź) Inny przykład sum(N,7) (nowy tryb użycia)

20 Dodawanie więzów nadmiarowych. Wiemy, że każda suma jest nieujemna (S9) sum(0, 0). (S10) sum(N, S+N) :- N >= 1, S >= 0, sum(N-1, S).

21 Dodawanie więzów nadmiarowych u nadmiarowe dla solwera: więz bazowy jest nadmiarowy dla solwera jeżeli wynika z magazynu więzów u korzyści: gdy solwer jest częściowy może dać extra informacje (failure) u F >= 1, N >= 1, FF = N*F, FF >= 1

22 Przykład (F1) fac(N, F) :- N = 0,F = 1. (F2) fac(N, FF) :- N >= 1, N1 = N - 1, FF = N * F, fac(N, F). fac(N,7) nie zatrzymuje się, jak sum(N,7). (F3) fac(N, F) :- N = 0,F = 1. (F4) fac(N, FF) :- N >= 1, N1 = N - 1, FF = N * F, F >= 1, fac(N, F). fac(N,7) podobnie

23 Przykład Gdy F >= 1 i N >= 4 to Musi być co najmniej 24. Solwer tego nie wykrywa!

24 Przykład (F3) fac(N, F) :- N = 0,F = 1. (F4) fac(N, FF) :- N >= 1, N1 = N - 1, FF = N * F, FF >= N, F >= 1, fac(N, F). Rozwiązanie: dodaj nadmiarowy (dla solwera) więz N * F >= N (wynika z N >= 1, F >= 1 ) Teraz fac(N,7) zawodzi (skończenie)

25 Minimalizacja u Literał minimalizacyjny powoduje przeszukiwanie innego drzewa wyprowadzeń minimize(G,E) ma taki sam tryb użycia jak E < m, G u dla efektywnej minimalizacji, zapewnij, że G jest efektywne, gdy E jest ograniczone z góry

26 Minimalizacja. Przykład Program znajdujący liście z głębokością leaf(node(null,X,null),X,0). leaf(node(L,_,_),X,D+1) :- leaf(L,X,D). leaf(node(_,_,R),X,D+1) :- leaf(R,X,D). Answers: X=h/\D=3 (h,3),(j,4),(k,4),(m,4), (o,5),(p,5),(f,2),(s,4), (t,4),(r,3)

27 Minimalizacja. Przykład minimize(leaf(t(a),X,D), D) : Po znalezieniu X = h /\ D = 3, działa jak D < 3 leaf(t(a),X,D), i nie powinien odwiedzać węzłów poniżej 3

28 Minimalizacja. Przykład Poprawiamy leaf dla D ograniczonego z góry dodając więz nadmiarowy. leaf(node(null,X,null),X,0). leaf(node(L,_,_),X,D+1) :- D >= 0, leaf(L,X,D). leaf(node(_,_,R),X,D+1) :- D >= 0, leaf(R,X,D).

29 Minimalizacja u Przeszukiwanie nie zawsze skorzysta z ograniczeń n.p.. minimize(leaf(t(a),X,D), -D) u Po odwiedzeniu jednego liścią dalej musi odwiedzić wszystkie węzły u oryginalne sformułowanie jest lepsze, bo wymaga mniejszej ilości więzów u Pamiętajmy o trybie użycia E<m, G

30 Wskazywanie determinizmu u Języki CLP zawierają konstrukcje, w których użytkownik wskazuje niedeterminizm i powoduje efektywniejsze wykonanie u if-then-else u once

31 If-Then-Else if-then-else l: (Gtest -> Gthen ; Gelse) u najpierw testuje Gtest, jeśli OK. to wykonuje Gthen w przeciwnym przypadku Gelse u if-then-else -- krok wyprowadzenia: G1 is L1, L2,..., Lm, gdzie L1 to (Gt -> Gn ; Ge) u if daje szczęśliwe,,najlewsze wyprowadzenie =>... => u C2 to C, G2 to Gn, L2,..., Lm u else C2 is C1, G2 is Ge, L2,..., Lm

32 Przykład u abs(X,Y) :- (X >= 0 -> Y = X ; Y = -X). u Jeśli X dodatnie to w.bezwgl. jest X, wpp -X

33 Przykład: zachowanie dla zapytań abs(X,2), X < 0 and X < 0, abs(X,2) zawodzi ?! sukces X = -2 ? NIEBEZPIECZEŃSTWO odpowiedź silnie zależy od trybu użycia używana jest jedynie pierwsza odpowiedź zaoytania Gt

34 Przykłady far_eq(X,Y) :- (apart(X,Y,4)-> true ; X = Y). apart(X,Y,D) :- X >= Y + D. apart(X,Y,D) :- Y >= X + D. X and Y are equal or at least 4 apart far_eq(1,6) succeeds, far_eq(1,3) fails far_eq(1,Y), Y = 6 fails WHY? test goal commits to first answer X >= Y + 4

35 If-Then-Else u bezpieczne użycie: wszystkie zmienne w Gtest ustalone u przykładowo: N i P0 ustalone cumul_pred([],_,P,P). cumul_pred([N|Ns],D,P0,P) :- (member(N,P0) -> P1 = P0 ; pred(N,D,[N|P0],P1) ), cumul_pred(Ns,D,P1,P).

36 Once u once: once(G) u znajduje jedno rozwiązanie G u once derivation step: G1 is L1, L2,..., Lm, where L1 is once(G) u if succeeds with leftmost successful derivation =>... => u C2 is C, G2 is L2,..., Lm u else C2 is false, G2 is []

37 Once Example u Sometimes all answers are equivalent u example: intersection u intersect([a,b,e,g,h],[b,e,f,g,i]) 72 states u 18 states intersect(L1,L2) :- member(X,L1), member(X,L2). intersect(L1,L2) :- once(member(X,L1), member(X,L2)).

38 Bridge Building Example u AIM: build 2 dimensional spaghetti bridges u Approach: first build a program to analyze bridges, then use it to constrain designs

39 Bridge Building Example u Constraints: u 20cm of struts, u strut of length L can sustain any stretch, only 0.5*(6-L)N compression, u floating joins can sustain any stretch, only 2N compression, sum of forces at a floating join is zero, one join in the center, at least 3 incident struts to a join, except center join only needs 2

40 Representing Bridges u list of joins u cjoin(x,y,l) (xy coords, list of incident struts) u join(x,y,l) u list of struts: strut(n,x1,y1,x2,y2) name and coords of endpoints u analysis of the bridge will create an association list of stretching forces in each strut f(n,f)

41 Representing Bridges js = [join(2,1,[a,c,d]), join(4,1,[d,e,g]), cjoin(3,-1,[b,c,e,f])] ss = [strut(a,0,0,2,1), strut(b,1,0,3,-1), strut(c,2,1,3,-1), strut(d,2,1,4,1), strut(e,3,-1,4,1), strut(g,4,1,6,0)]

42 Strut Constraints strutc([],[],0). strutc([strut(N,X1,Y1,X2,Y2)|Ss], [f(N,F) |Fs], TL):- L = sqrt((X1-X2)*(X1-X2)+ (Y1-Y2)*(Y1-Y2)), F >= -0.5 * (6 - L), TL = L + RL, strutc(Ss, Fs, RL). Builds force association list, calculates total length, asserts max compression force

43 Strut Constraints u Given a fixed list of struts works well u Like sum total length only causes failure at end u FIX add answer redundant constraint RL >= 0 u If the coords of the struts are not fixed length calculation is non-linear (incomplete) u (partial) FIX add solver redundant constraints (linear approximation)

44 Summing Forces sumf([],_,_,_,0,0). sumf([N|Ns],X,Y,Ss,Fs,SFX,SFY) :- member(strut(N,X1,Y1,X2,Y2),Ss), end(X1,Y1,X2,Y2,X,Y,X0,Y0), member(f(N,F),Fs), F <= 2, L = sqrt((X1-X2)*(X1-X2)+ (Y1-Y2)*(Y1-Y2)), FX = F*(X-X0)/L, FY = F*(Y-Y0)/L, SFX = FX+RFX, SFY = FY+RFY, sumf(Ns,X,Y,Ss,Fs,RFX,RFY). end(X,Y,X0,Y0,X,Y,X0,Y0). end(X0,Y0,X,Y,X,Y,X0,Y0).

45 Join Constraints joinc([],_,_,_). joinc([J|Js],Ss,Fs,W) :- onejoin(J,Ss,Fs,W). joinc(Js,Ss,Fs,W). onejoin(cjoin(X,Y,Ns),Ss,Fs,W) :- Ns = [_,_|_], sumf(Ns,X,Y,Ss,Fs,0,W). onejoin(join(X,Y,Ns),Ss,Fs,W) :- Ns = [_,_,_|_], sumf(Ns,X,Y,Ss,Fs,0,0). Apply minimum incident struts and sum forces cons.

46 Join Constraints u Given a fixed list of struts for each join, works well non-deterministic because of end although there is only one answer u hence use inside once

47 Bridge Analysis u For the illustrated bridge TL <= 20, strutc(ss,Fs,TL), once(joinc(js,ss,Fs,W)). u Answer is W <= 2.63

48 Bridge Design strutc and joinc require the topology to be known to avoid infinite derivations u too many topologies to search all one approach user defines topology tpl(Js,Ss,Vs) where Vs are the coordinate variables u system performs minimization search

49 Bridge Design u Unfortunately constraints are nonlinear so minimization goal will not work u instead add explicit search to minimize on which fixes all coordinates tpl(Js,Ss,Vs), TL <= 20, strutc(Ss,Fs,TL), once(joinc(Js,Ss,Fs,W)), minimize(position(Vs), -W). u Answer W=6.15 /\ Vs=[2,2,5,1,3,3]

50 Position Search position([]). position([V|Vs]) :- member(V,[6,5,4,3,2,1,0,-1,-2]), position(Vs). Simply try each possible value in turn for each variable More about this kind of search in the next chapter

51 Bridge Design u Integer coordinates are very restrictive u Idea: use local search to improve the design u find an optimal (integer) solution u try moving coordinate + or for better sol u if so then try +/ etc. until solution doesnt improve very much u Best local search answer u W=6.64 /\ Vs=[2.125,2.625,3.875,2.635,3,3.75]

52 Perturbation Search perturbation([],[],_). perturbation([V|Vs],[Val|Vals],D) :- perturb(V,Val,D), perturbation(Vs,Vals,D). perturb(V,Val,D) :- V = Val-D. perturb(V,Val,D) :- V = Val. perturb(V,Val,D) :- V = Val+D. improve(Vs,W,FVs,FW,D) :- bridge(NW,NVs), NW >= W, once(minimize(perturbation(NVs,Vs,D),-NW)), (NW FVs = Vs,FW= W ; improve(NVs,NW,FVs,FW,D/2)).

53 Controlling Search Summary u Efficiency is measured as size of derivation tree u Depends on the mode of usage of predicates u Change size and shape by reordering literals and rules (doesnt change answers) u Add redundant constraints to prune branches (doesnt change answers) u Use if-then-else and once to identify sub- computations which dont need backtracking