Skip to content

Instantly share code, notes, and snippets.

@jiribenes

jiribenes/1-graf.prolog Secret

Last active Mar 11, 2021
Embed
What would you like to do?
Cvičení z Neprocedurálního programování - 2
% Bavili jsme se o unifikaci a backtrackingu....
% Pokračování grafů z minulého cvičení:
%
% A ------> B ---> C
% \ \ /|
% \| \| /
% E----------->F
% \ /|
% \| /
% D /
% /| /
% / /
% G ---> H
edge(a, b).
edge(a, e).
edge(b, c).
edge(b, f).
edge(e, d).
edge(e, f).
edge(f, c).
edge(g, d).
edge(g, h).
edge(h, f).
% Chceme definovat 'path(U, V)', který značí jestli existuje orientovaná cesta z U do V
% Hranu z U do V značím jako U -> V
% Orientovanou cestu z U do V značím jako U ~~~> V
% Níže jsou definovány tři varianty:
% * `path` je verze z prvního cvičení - najde výsledek a nezacyklí se
% * `path2` je nová verze - sice najde výsledek, ale zacyklí se
% * `path3` je nová verze - jen se zacyklí
% Hlavně jsme řešili rozdíl mezi "deklarativní správností", cca "formule daná pravidlem je správně"
% versus "procedurální správností", cca "dá správný výsledek"
% funguje z minulého cvičení
path(U, V) :- edge(U, V).
path(U, V) :- edge(U, W), path(W, V).
% najde výsledek a pak se zacyklí
path2(U, V) :- edge(U, V).
path2(U, V) :- path2(W, V), edge(U, W).
% zacyklí
path3(U, V) :- edge(U, W), path3(W, V).
path3(U, V) :- edge(U, V).
% Můžeme si vytvořit složené termy
% Nepotřebujeme dopředu definovat tvar takových termů,
% narozdíl od Céčka, kde bychom museli napsat `struct pair { int a; int b; }`
% Vrátí první, resp. druhý člen dvojice.
% `_` znamená "Vytvoř novou proměnnou, která je různá od
% všech již existujících proměnných"
first(pair(A, _), A).
second(pair(_, B), B).
%% unární reprezentace čísel
%% Taky se ji říká "Peanova aritmetika"
% 0 značí nulu
% s(X) značí následníka čísla X, tedy X + 1
% nat: je něco číslo?
nat(0). % 0 je číslo
nat(s(X)) :- nat(X). % (X + 1) je číslo, pokud X je číslo
% Příklady čísel:
% zero = 0.
% one = s(0). % successor of 0
% two = s(s(0)).
% three = s(s(s(0))).
% Chceme zadefinovat sčítání:
% add(X, Y, Z)
% 0 + X = X
add(0,X,X) :- nat(X).
% (X + 1) + Y = (Z + 1) if X + Y = Z
add(s(X), Y, s(Z)) :-
nat(X), nat(Y), nat(Z),
add(X, Y, Z).
% Tracujeme ručně `add(1,2,A)`:
% add(1, 2, A)
% = add(s(0), s(s(0)), A)
% ~> basecase
% <~ no.
% ~> X = 0, Y = s(s(0)), A = s(Z)
% ~> add(0, s(s(0)), Z)
% ~> basecase: X' = s(s(0)), Z = X'
%
% X = 0, Y = s(s(0)), X' = s(s(0))
%
% A = s(Z) = s(X') = s(s(s(0))).
% Doporučuji si výše uvedené vytraceovat i v REPLu
% Násobení
% mult(X, Y, Z)
% basecase
mult(0,X,0).
% Rozmyslete si, že tenhle basecase vlastně není potřeba
mult(s(0),X,X).
% rekurzivní případ
% (X + 1) * Y = (X*Y) + Y = M + Y = Z
mult(s(X), Y, Z) :-
mult(X, Y, M), % X * Y = M
add(M, Y, Z). % M + Y = Z
% Cvičení: Vytvořte `less_equal(X, Y)`, který platí pokud X <= Y,
% kde X, Y jsou čísla zadaná v Peanově aritmetice
% Cvičení: Vytvořte dělení dvěma -- `divTwo(X, Y)`, tedy Y := X / 2 (celočíselně).
% Uměli byste i obecné celočíselné dělení -- `div(X, Y, Z)`?
% Dál jsme se vrhli na seznamy
% a rovnou jsme se rozhodli si vyrobit vlastní složené termy,
% které reprezentují seznam.
% nil .... prázdný seznam
% cons(X, Y) .... X je hlava seznamu [head]
% , Y je tělo (ocásek) [tail]
%
% Predikát `list(X)` značí jestli `X` je seznam.
list(nil). % prázdný seznam je seznam
list(cons(Head, Tail)) :- % dvojice (Head, Tail) je seznam iff Tail je seznam
list(Tail).
% příklad seznamu [1, 2, "test"]
% cons(1, cons(2, cons("test", nil)))
% `printlist(X)` vypíše obsah stringového seznamu.
% (To, že obsahuje stringy nikde nekontrolujeme)
printlist(nil).
printlist(cons(String, Tail)) :-
writeln(String),
printlist(Tail).
% Můžeme si představit, že Prolog uvnitř funguje následovně:
% (Opravdové seznamy v Prologu vs. ty naše custom seznamy)
%
% [] ~~~> nil
% [1, 2, 3] ~~~> cons(1, cons(2, cons(3, nil)))
% [Head|Tail] <~~~ cons(Head, Tail)
% `printlist`, jen pro seznamy se syntaktickým cukrem.
printlist2([]).
printlist2([String|Tail]) :-
writeln(String),
printlist2(Tail).
% Doopravdy to je tak, že Prolog podporuje operátory a má:
% * nulární operátor [] ... reprezentuje náš `nil`
% * binární operátor [X|Y] ... reprezentuje náš `cons(X, Y)`
%
% Potom následující notace jsou ekvivalentní:
% [1, 2, "test"]
% cons(1, cons(2, cons("test", nil))) ... pozor, tahle notace je jen naše, nebude fungovat na predikáty v Prologu
% [1|[2|["test"|[]]]] ... explicitně napsaný [1, 2, "test"] pomocí operátorů
% Tohle by mělo být `true`, je to takový důkaz, že nekecám. :)
stejny :- [1, 2, "test"] = [1|[2|["test"|[]]]].
% náleží prvek seznamu?
% standardně ve std knihovně jako `member/2`, tedy funkce `member`, která bere 2 argumenty
elem(X, [X|_]).
elem(X, [_|T]) :- elem(X, T).
% Tahle verze `elem` skáče po dvou prvcích
% elem(X, [X, _|_]).
% elem(X, [_, _|T]) :- elem(X, T).
% Jak namatchovat správný seznam:
% f([A, B]) ... uspěje pro seznamy délky 2
% f([A, B | Tail]) ... uspěje pro seznamy délky >=2
% Hádanka, co dělá tahle funkce?
foo([], X, X).
foo([H|T], Y, [H|R]) :- foo(T, Y, R).
% standardně se jmenuje append/3 ;)
% Tuhle funkci jsme napsali omylem
identita([], []).
identita([H|T], [H|R]) :- identita(T, R).
% Reálně jen "přestaví" seznam znovu beze změny.
% Konkrétně nahlédněte, že určitě seznam neotáčí :)
% Otočí spojový seznam
% Tahle funkce je technicky O(N^2), jde to i lineárně,
% jak uvidíme příště. :)
% V knihovně ji najdete jako `reverse/2`.
otoc([], []).
otoc([Head|Tail], Result) :-
otoc(Tail, ReversedTail), % ... otočíme ocásek
append(ReversedTail, [Head], Result). % ... na konec otočeného ocásku připneme jednoprvkový seznam `[Head]`
% a výsledek označíme jako `Result`.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment