Logic Programming. Using Data Structures Part 2. Temur Kutsia
|
|
|
- Beatrix Bruce
- 5 years ago
- Views:
Transcription
1 Logic Programming Using Data Structures Part 2 Temur Kutsia Research Institute for Symbolic Computation Johannes Kepler University of Linz, Austria kutsia@risc.uni-linz.ac.at
2 Contents Recursive Comparison Joining Structures Together Accumulators Difference Structures
3 Comparing Structures Structure comparison: More complicated than the simple integers Have to compare all the individual components Break down components recursively.
4 Comparing Structures. aless Example aless(x,y) succeeds if X and Y stand for atoms and X is alphabetically less than Y. aless(avocado,clergyman) succeeds. aless(windmill,motorcar) fails. aless(picture,picture) fails.
5 Comparing Structures. aless Success First word ends before second: aless(book,bookbinder). Success A character in the first is alphabetically less than one in the second: aless(avocado,clergyman). Recursion The first character is the same in both. Then have to check the rest: For aless(lazy,leather) check aless(azy,eather). Failure Reach the end of both words at the same time: aless(apple,apple). Failure Run out of characters for the second word: aless(alphabetic,alp).
6 Representation Transform atoms into a recursive structure. List of integers (ASCII codes). Use built-in predicate atom_codes:?- atom_codes(alp,[97,108,112]). yes?- atom_codes(alp,x). X = [97,108,112]? yes?-atom_codes(x,[97,108,112]). X = alp? yes
7 First Task Convert atoms to lists: Compare the lists: Putting together: atom_codes(x, XL). atom_codes(y, YL). alessx(xl, YL). aless(x,y):- atom_codes(x, XL), atom_codes(y, YL), alessx(xl, YL).
8 Second Task Compose alessx. Success First word ends before second: alessx([],[_ _]). Success A character in the first is alphabetically less than one in the second: alessx([x _],[Y _]):-X<Y. Recursion The first character is the same in both. Then have to check the rest: alessx([h X],[H Y]):-alessx(X,Y). What about failing cases?
9 Program aless(x, Y):- atom_codes(x, XL), atom_codes(y, YL), alessx(xl, YL). alessx([], [_ _]). alessx([x _], [Y _]):- X < Y. alessx([h X], [H Y]):- alessx(x, Y).
10 Appending Two Lists For any lists List1, List2, and List3 List2 appended to List1 is List3 iff either List1 is the empty list and List3 is List2, or List1 is a nonempty list and the head of List3 is the head of List1 and the tail of List3 is List2 appended to the tail of List1. Program: append([],l,l). append([x L1],L2,[X L3]):-append(L1,L2,L3).
11 Using append Test?- append([a,b,c],[2,1],[a,b,c,2,1]). Total List?- append([a,b,c],[2,1],x). Isolate?- append(x,[2,1],[a,b,c,2,1]).?- append([a,b,c],x,[a,b,c,2,1]). Split?- append(x,y,[a,b,c,2,1]).
12 Inventory Example Bicycle factory To build a bicycle we need to know which parts to draw from the supplies. Each part of a bicycle may have subparts. Task: Construct a tree-based database that will enable users to ask questions about which parts are required to build a part of bicycle.
13 Parts of a Bicycle Basic parts: basicpart(rim). basicpart(spoke). basicpart(rearframe). basicpart(handles). basicpart(gears). basicpart(bolt). basicpart(nut). basicpart(fork). Assemblies, consisting of a quantity of basic parts or other assemblies: assembly(bike,[wheel,wheel,frame]). assembly(wheel,[spoke,rim,hub]). assembly(frame,[rearframe,frontframe]). assembly(hub,[gears,axle]). assembly(axle,[bolt,nut]). assembly(frontframe,[fork,handles]).
14 Bike as a Tree bike wheel wheel frame spoke rim hub spoke rim hub rearfr. frontfr. gears axle gears axle fork handles bolt nut bolt nut
15 Program Write a program that, given a part, will list all the basic parts required to construct it. Idea: 1. If the part is a basic part then nothing more is required. 2. If the part is an assembly, apply the same process (of finding subparts) to each part of it.
16 Predicates: partsof partsof(x,y): Succeeds if X is a part of bike, and Y is the list of basic parts required to construct X. Boundary condition. Basic part: partsof(x,[x]):-basicpart(x). Assembly: partsof(x,p):- assembly(x,subparts), partsoflist(subparts,p). Need to define partsoflist.
17 Predicates: partsoflist Boundary condition. List of parts for the empty list is empty: partsoflist([],[]). Recursive case. For a nonempty list, first find partsof of the head, then recursively call partsoflist on the tail of the list, and glue the obtained lists together: partsoflist([p Tail],Total):- partsof(p,headparts), partsoflist(tail,tailparts), append(headparts,tailparts,total). The same example using accumulators
18 Finding Parts?- partsof(bike,parts). Parts=[spoke,rim,gears,bolt,nut,spoke,rim, gears,bolt,nut,rearframe,fork,handles] ; No?- partsof(wheel,parts). Parts=[spoke, rim, gears, bolt, nut] ; No
19 Using Intermediate Results Frequent situation: Traverse a PROLOG structure. Calculate the result which depends on what was found in the structure. At intermediate stages of the traversal there is an intermediate value for the result. Common technique: Use an argument of the predicate to represent the "answer so far". This argument is called an accumulator.
20 Length of a List without Accumulators Example listlen(l,n) succeeds if the length of list L is N. Boundary condition. The empty list has length 0: listlen([],0). Recursive case. The length of a nonempty list is obtained by adding one to the length of the tail of the list. listlen([h T],N):- listlen(t,n1), N is N1 + 1.
21 Length of a List with an Accumulator Example listlenacc(l,a,n) succeeds if the length of list L, when added the number A, is N. Boundary condition. For the empty list, the length is whatever has been accumulated so far, i.e. A: lenacc([],a, A). Recursive case. For a nonempty list, add 1 to the accumulated amount given by A, and recur to the tail of the list with a new accumulator value A1: lenacc([h T],A,N):- A1 is A + 1, lenacc(t,a1,n).
22 Length of a List with an Accumulator, Cont. Example Complete program: listlen(l,n):-lenacc(l,0,n). lenacc([],a, A). lenacc([h T],A,N):- A1 is A + 1, lenacc(t,a1,n).
23 Computing List Length Example (Version without Accumulator)
24 Computing List Length Example (Version without Accumulator) listlen([a,b,c],n).
25 Computing List Length Example (Version without Accumulator) listlen([a,b,c],n). listlen([b,c],n1), N is N1 + 1.
26 Computing List Length Example (Version without Accumulator) listlen([a,b,c],n). listlen([b,c],n1), N is N listlen([c],n2), N1 is N2 + 1, N is N1 + 1.
27 Computing List Length Example (Version without Accumulator) listlen([a,b,c],n). listlen([b,c],n1), N is N listlen([c],n2), N1 is N2 + 1, N is N listlen([],n3), N2 is N3 + 1, N1 is N2 + 1, N is N1 + 1.
28 Computing List Length Example (Version without Accumulator) listlen([a,b,c],n). listlen([b,c],n1), N is N listlen([c],n2), N1 is N2 + 1, N is N listlen([],n3), N2 is N3 + 1, N1 is N2 + 1, N is N N2 is 0 + 1, N1 is N2 + 1, N is N1 + 1.
29 Computing List Length Example (Version without Accumulator) listlen([a,b,c],n). listlen([b,c],n1), N is N listlen([c],n2), N1 is N2 + 1, N is N listlen([],n3), N2 is N3 + 1, N1 is N2 + 1, N is N N2 is 0 + 1, N1 is N2 + 1, N is N N1 is 1 + 1, N is N1 + 1.
30 Computing List Length Example (Version without Accumulator) listlen([a,b,c],n). listlen([b,c],n1), N is N listlen([c],n2), N1 is N2 + 1, N is N listlen([],n3), N2 is N3 + 1, N1 is N2 + 1, N is N N2 is 0 + 1, N1 is N2 + 1, N is N N1 is 1 + 1, N is N N is
31 Computing List Length Example (Version without Accumulator) listlen([a,b,c],n). listlen([b,c],n1), N is N listlen([c],n2), N1 is N2 + 1, N is N listlen([],n3), N2 is N3 + 1, N1 is N2 + 1, N is N N2 is 0 + 1, N1 is N2 + 1, N is N N1 is 1 + 1, N is N N is N = 3
32 Computing List Length Example (Version with an Accumulator) listlen([a,b,c],0,n).
33 Computing List Length Example (Version with an Accumulator) listlen([a,b,c],0,n). listlen([b,c],1,n).
34 Computing List Length Example (Version with an Accumulator) listlen([a,b,c],0,n). listlen([b,c],1,n). listlen([c],2,n).
35 Computing List Length Example (Version with an Accumulator) listlen([a,b,c],0,n). listlen([b,c],1,n). listlen([c],2,n). listlen([],3,n).
36 Computing List Length Example (Version with an Accumulator) listlen([a,b,c],0,n). listlen([b,c],1,n). listlen([c],2,n). listlen([],3,n). N = 3
37 List as an Accumulator Accumulators need not be integers. If a list is to be produced as a result, an accumulator will hold a list produced so far. Wasteful joining of structures avoided. Example (Reversing Lists) reverse(list, Rev):-rev_acc(List,[],Rev). rev_acc([],acc,acc). rev_acc([x T], Acc, Rev):- rev_acc(t,[x Acc],Rev).
38 Bicycle Factory Recall how parts of bike were found. Inventory example partsoflist has to find the parts coming from the list [wheel,wheel,frame]: Find parts of frame. Append them to [] to find parts of [frame]. Find parts of wheel. Append them to the parts of [frame] to find parts of [wheel,frame]. Find parts of wheel. Append them to the parts of [wheel,frame] to find parts of [wheel,wheel,frame]. Wasteful!
39 Bicycle Factory Improvement idea: Get rid of append. Use accumulators. partsof(x,p):-partsacc(x,[],p). partsacc(x,a,[x A]):-basicpart(X). partsacc(x,a,p):- assembly(x,subparts), partsacclist(subparts,a,p). partsacclist([],a,a). partsacclist([p Tail],A,Total):- partsacc(p,a,headparts), partsacclist(tail,headparts,total). partsacc(x,a,p): parts of X, when added to A, give P.
40 Difference Structures Compute parts of wheel without and with accumulator: Example (Without Accumulator)?- partsof(wheel,p). X = [spoke, rim, gears, bolt, nut] ; No Example (With Accumulator)?- partsof(wheel,p). X = [nut, bolt, gears, rim, spoke] ; No Reversed order.
41 Difference Structures How to avoid wasteful work and retain the original order at the same time? Difference structures.
42 Open Lists and Difference Lists Consider the list [a,b,c Ho]. The structure of the list is known up to a point. If, at some point, Ho is unbound then we have an open list. Informally, Ho is a called a hole.
43 Open Lists and Difference Lists Unify Ho with [d,e]:?- List=[a,b,c Ho], Ho=[d,e].
44 Open Lists and Difference Lists Unify Ho with [d,e]:?- List=[a,b,c Ho], Ho=[d,e]. List=[a,b,c,d,e]
45 Open Lists and Difference Lists Unify Ho with [d,e]:?- List=[a,b,c Ho], Ho=[d,e]. List=[a,b,c,d,e] We started with an open list and filled in the hole with the structure.
46 Open Lists and Difference Lists The result of filling in the hole in an open list with a proper list is a proper list. What happens if we instantiate the hole with an open list?
47 Open Lists and Difference Lists The result of filling in the hole in an open list with a proper list is a proper list. What happens if we instantiate the hole with an open list? The result will be an open list again:?- List=[a,b,c Ho], Ho=[d,e Y].?- List=[a,b,c,d,e Y].
48 Open Lists and Difference Lists Filling in the hole with a proper list, again:?- List=[a,b,c Ho], Ho=[d,e].?- List=[a,b,c,d,e]. Is not it the same as append([a,b,c],[d,e],list)?
49 open_append We can define append in terms of hole filling. Assume the first list is given as an open list. Define a predicate that fills in the hole with the second list. A naive and limited way of doing this: open_append([h1,h2,h3 Hole],L2):-Hole=L2.
50 open_append We can define append in terms of hole filling. Assume the first list is given as an open list. Define a predicate that fills in the hole with the second list. A naive and limited way of doing this: open_append([h1,h2,h3 Hole],L2):-Hole=L2.?- List=[a,b,c Ho], open_append(list,[d,e]).
51 open_append We can define append in terms of hole filling. Assume the first list is given as an open list. Define a predicate that fills in the hole with the second list. A naive and limited way of doing this: open_append([h1,h2,h3 Hole],L2):-Hole=L2.?- List=[a,b,c Ho], open_append(list,[d,e]). List=[a,b,c,d,e] Ho=[d,e]
52 open_append We can define append in terms of hole filling. Assume the first list is given as an open list. Define a predicate that fills in the hole with the second list. A naive and limited way of doing this: open_append([h1,h2,h3 Hole],L2):-Hole=L2.?- List=[a,b,c Ho], open_append(list,[d,e]). List=[a,b,c,d,e] Ho=[d,e] Improvement is needed: This version assumes having a list with three elements and the hole.
53 Improvement Idea One often wants to say about open lists something like take the open list and fill in the hole with... Hence, one should know both an open list and a hole. Idea for list representation: Represent a list as an open list together with the hole. Such a representation is called a difference list. Example: The difference list representation of the list [a,b,c] is the pair of terms [a,b,c X] and X.
54 diff_append Difference append: diff_append(openlist,hole,l2):-hole=l2.
55 diff_append Difference append: diff_append(openlist,hole,l2):-hole=l2.?- List=[a,b,c Ho], diff_append(list,ho,[d,e]).
56 diff_append Difference append: diff_append(openlist,hole,l2):-hole=l2.?- List=[a,b,c Ho], diff_append(list,ho,[d,e]). List=[a,b,c,d,e] Ho=[d,e]
57 diff_append Difference append: diff_append(openlist,hole,l2):-hole=l2.?- List=[a,b,c Ho], diff_append(list,ho,[d,e]). List=[a,b,c,d,e] Ho=[d,e] Compare to the open_append: open_append([h1,h2,h3 Hole],L2):-Hole=L2.
58 diff_append Difference append: diff_append(openlist,hole,l2):-hole=l2.?- List=[a,b,c Ho], diff_append(list,ho,[d,e]). List=[a,b,c,d,e] Ho=[d,e] Compare to the open_append: open_append([h1,h2,h3 Hole],L2):-Hole=L2.?- List=[a,b,c Ho], open_append(list,[d,e]). List=[a,b,c,d,e] Ho=[d,e]
59 Difference Lists Introduce a notation for difference lists. Idea: We are usually interested the open list part of difference list, without the hole.
60 Difference Lists Introduce a notation for difference lists. Idea: We are usually interested the open list part of difference list, without the hole. From the pair [a,b,c Ho] and Ho we are interested in [a,b,c].
61 Difference Lists Introduce a notation for difference lists. Idea: We are usually interested the open list part of difference list, without the hole. From the pair [a,b,c Ho] and Ho we are interested in [a,b,c]. Subtracting the hole Ho from the open list [a,b,c Ho].
62 Difference Lists Introduce a notation for difference lists. Idea: We are usually interested the open list part of difference list, without the hole. From the pair [a,b,c Ho] and Ho we are interested in [a,b,c]. Subtracting the hole Ho from the open list [a,b,c Ho]. [a,b,c Ho]-Ho.
63 Difference Lists Introduce a notation for difference lists. Idea: We are usually interested the open list part of difference list, without the hole. From the pair [a,b,c Ho] and Ho we are interested in [a,b,c]. Subtracting the hole Ho from the open list [a,b,c Ho]. [a,b,c Ho]-Ho. The - has no interpreted meaning. Instead one could define any operator to use there.
64 diff_append. Version 2 diff_append(openlist-hole,l2):-hole=l2.
65 diff_append. Version 2 diff_append(openlist-hole,l2):-hole=l2.?- DList=[a,b,c Ho]-Ho, diff_append(dlist,[d,e]).
66 diff_append. Version 2 diff_append(openlist-hole,l2):-hole=l2.?- DList=[a,b,c Ho]-Ho, diff_append(dlist,[d,e]). DList=[a,b,c,d,e]-[d,e] Ho=[d,e]
67 diff_append. Version 2 diff_append(openlist-hole,l2):-hole=l2.?- DList=[a,b,c Ho]-Ho, diff_append(dlist,[d,e]). DList=[a,b,c,d,e]-[d,e] Ho=[d,e] Has to be improved again: We are not interested in the filled hole in the instantiation of Ho hanging around.
68 diff_append. Version 3 Let diff_append return the open list part of the first argument: diff_append(openlist-hole,l2,openlist):-hole=l2.
69 diff_append. Version 3 Let diff_append return the open list part of the first argument: diff_append(openlist-hole,l2,openlist):-hole=l2.?- DList=[a,b,c Ho]-Ho, diff_append(dlist,[d,e],ans).
70 diff_append. Version 3 Let diff_append return the open list part of the first argument: diff_append(openlist-hole,l2,openlist):-hole=l2.?- DList=[a,b,c Ho]-Ho, diff_append(dlist,[d,e],ans). Dlist=[a,b,c,d,e]-[d,e] Ho=[d,e] Ans=[a,b,c,d,e]
71 diff_append. Version 3 Let diff_append return the open list part of the first argument: diff_append(openlist-hole,l2,openlist):-hole=l2.?- DList=[a,b,c Ho]-Ho, diff_append(dlist,[d,e],ans). Dlist=[a,b,c,d,e]-[d,e] Ho=[d,e] Ans=[a,b,c,d,e] It is better now. Ans looks as we would like to.
72 diff_append. Version 3 Let diff_append return the open list part of the first argument: diff_append(openlist-hole,l2,openlist):-hole=l2.?- DList=[a,b,c Ho]-Ho, diff_append(dlist,[d,e],ans). Dlist=[a,b,c,d,e]-[d,e] Ho=[d,e] Ans=[a,b,c,d,e] It is better now. Ans looks as we would like to. Still, there is a room for improvement: The diff_append takes a difference list as its first argument, a proper list as its second argument, and returns a proper list. Let s make it more uniform.
73 diff_append. Version 3 Better, but not the final approximation: diff_append takes two difference lists and returns an open list: diff_append(openlist1-hole1, OpenList2-Hole2, OpenList1):-Hole1=OpenList2.
74 diff_append. Version 3 Better, but not the final approximation: diff_append takes two difference lists and returns an open list: diff_append(openlist1-hole1, OpenList2-Hole2, OpenList1):-Hole1=OpenList2.?- Dlist=[a,b,c Ho]-Ho, diff_append(dlist,[d,e Ho1]-Ho1,Ans).
75 diff_append. Version 3 Better, but not the final approximation: diff_append takes two difference lists and returns an open list: diff_append(openlist1-hole1, OpenList2-Hole2, OpenList1):-Hole1=OpenList2.?- Dlist=[a,b,c Ho]-Ho, diff_append(dlist,[d,e Ho1]-Ho1,Ans). Dlist=[a,b,c,d,e Ho1]-[d,e Ho1] Ho=[d,e Ho1] Ans=[a,b,c,d,e Ho1]
76 diff_append. Version 3 Better, but not the final approximation: diff_append takes two difference lists and returns an open list: diff_append(openlist1-hole1, OpenList2-Hole2, OpenList1):-Hole1=OpenList2.?- Dlist=[a,b,c Ho]-Ho, diff_append(dlist,[d,e Ho1]-Ho1,Ans). Dlist=[a,b,c,d,e Ho1]-[d,e Ho1] Ho=[d,e Ho1] Ans=[a,b,c,d,e Ho1] We have returned an open list but we want a difference list.
77 diff_append. Version 3 Better, but not the final approximation: diff_append takes two difference lists and returns an open list: diff_append(openlist1-hole1, OpenList2-Hole2, OpenList1):-Hole1=OpenList2.?- Dlist=[a,b,c Ho]-Ho, diff_append(dlist,[d,e Ho1]-Ho1,Ans). Dlist=[a,b,c,d,e Ho1]-[d,e Ho1] Ho=[d,e Ho1] Ans=[a,b,c,d,e Ho1] We have returned an open list but we want a difference list. The first list has gained the hole of the second list.
78 diff_append. Version 3 Better, but not the final approximation: diff_append takes two difference lists and returns an open list: diff_append(openlist1-hole1, OpenList2-Hole2, OpenList1):-Hole1=OpenList2.?- Dlist=[a,b,c Ho]-Ho, diff_append(dlist,[d,e Ho1]-Ho1,Ans). Dlist=[a,b,c,d,e Ho1]-[d,e Ho1] Ho=[d,e Ho1] Ans=[a,b,c,d,e Ho1] We have returned an open list but we want a difference list. The first list has gained the hole of the second list. All we need to ensure is that we return the hole of the second list.
79 diff_append. Version 3 Return the hole of the second list as well: diff_append(openlist1-hole1, OpenList2-Hole2, OpenList1-Hole2):-Hole1=OpenList2.
80 diff_append. Version 3 Return the hole of the second list as well: diff_append(openlist1-hole1, OpenList2-Hole2, OpenList1-Hole2):-Hole1=OpenList2.?- DList=[a,b,c Ho]-Ho, diff_append(dlist,[d,e Ho1]-Ho1,Ans).
81 diff_append. Version 3 Return the hole of the second list as well: diff_append(openlist1-hole1, OpenList2-Hole2, OpenList1-Hole2):-Hole1=OpenList2.?- DList=[a,b,c Ho]-Ho, diff_append(dlist,[d,e Ho1]-Ho1,Ans). DList=[a,b,c,d,e Ho1]-[d,e Ho1] Ho=[d,e Ho1] Ans=[a,b,c,d,e Ho1]-Ho1
82 diff_append. Version 3 Return the hole of the second list as well: diff_append(openlist1-hole1, OpenList2-Hole2, OpenList1-Hole2):-Hole1=OpenList2.?- DList=[a,b,c Ho]-Ho, diff_append(dlist,[d,e Ho1]-Ho1,Ans). DList=[a,b,c,d,e Ho1]-[d,e Ho1] Ho=[d,e Ho1] Ans=[a,b,c,d,e Ho1]-Ho1 We have returned an difference list.
83 diff_append. Version 3 Return the hole of the second list as well: diff_append(openlist1-hole1, OpenList2-Hole2, OpenList1-Hole2):-Hole1=OpenList2.?- DList=[a,b,c Ho]-Ho, diff_append(dlist,[d,e Ho1]-Ho1,Ans). DList=[a,b,c,d,e Ho1]-[d,e Ho1] Ho=[d,e Ho1] Ans=[a,b,c,d,e Ho1]-Ho1 We have returned an difference list. Now we can recover the proper list we want this way:
84 diff_append. Version 3 Return the hole of the second list as well: diff_append(openlist1-hole1, OpenList2-Hole2, OpenList1-Hole2):-Hole1=OpenList2.?- DList=[a,b,c Ho]-Ho, diff_append(dlist,[d,e Ho1]-Ho1,Ans). DList=[a,b,c,d,e Ho1]-[d,e Ho1] Ho=[d,e Ho1] Ans=[a,b,c,d,e Ho1]-Ho1 We have returned an difference list. Now we can recover the proper list we want this way:?- DList=[a,b,c Ho]-Ho, diff_append(dlist,[d,e Ho1]-Ho1,Ans-[]). Ans=[a,b,c,d,e]
85 diff_append. Version 4 diff_append can be made more compact: diff_append(openlist1-hole1, Hole1-Hole2, OpenList1-Hole2).
86 diff_append. Usage Add an element at the end of a list: add_to_back(l-h,el,ans):- diff_append(l-h,[el H1]-H1,Ans-[]).
87 diff_append. Usage Add an element at the end of a list: add_to_back(l-h,el,ans):- diff_append(l-h,[el H1]-H1,Ans-[]).?- add_to_back([a,b,c H]-H,e,Ans).
88 diff_append. Usage Add an element at the end of a list: add_to_back(l-h,el,ans):- diff_append(l-h,[el H1]-H1,Ans-[]).?- add_to_back([a,b,c H]-H,e,Ans). H = [e] Ans = [a,b,c,e]
89 Difference Structures Both accumulators and difference structures use two arguments to build the output structure. Assumulators: the result so far and the final result. Difference structures: the (current approximation of the) final result and the hole in there where the further information can be put.
90 Bicycle Factory Use holes. partsof(x,p):-partshole(x,p-hole),hole=[]. partshole(x,[x Hole]-Hole):-basicpart(X). partshole(x,p-hole):- assembly(x,subparts), partsholelist(subparts,p-hole). partsholelist([],hole-hole). partsholelist([p Tail],Total-Hole):- partshole(p,total-hole1), partsholelist(tail,hole1-hole).
91 Bicycle Factory. Detailed View partsof(x,p):-partshole(x,p-hole),hole=[]. partshole(x,p-hole) builds the result in the second argument P and returns in Hole a variable. Since partsof calls partshole only once, it is necessary to terminate the difference list by instantiating Hole with []. (Filling the hole.) Alternative definition of partsof: partsof(x,p):-partshole(x,p-[]). It ensures that the very last hole is filled with [] even before the list is constructed.
92 Bicycle Factory. Detailed View partshole(x,[x Hole]-Hole):-basicpart(X). It returns a difference list containing the object (basic part) in the first argument. The hole remains open for further instantiations.
93 Bicycle Factory. Detailed View partshole(x,p-hole):- assembly(x,subparts), partsholelist(subparts,p-hole). Finds the list of subparts. Delegates the traversal of the list to partsholelist. The difference list P-Holeis passed to partsholelist.
94 Bicycle Factory. Detailed View partsholelist([p Tail],Total-Hole):- partshole(p,total-hole1), partsholelist(tail,hole1-hole). partshole starts building the Total list, partially filling it with the parts of P, and leaving a hole Hole1 in it. partsholelist is called recursively on the Tail. It constructs the list Hole1 partially, leaving a hole Hole in it. Since Hole1 is shared between partshole and partsholelist, after getting instantiated in partsholelist it gets also instantiated in partshole. Therefore, at the end Total consists of the portion that partshole constructed, the portion of Hole1 partsholelist constructed, and the hole Hole.
Accumulators! More on Arithmetic! and! Recursion!
Accumulators! More on Arithmetic! and! Recursion! Acc-1 L is a list of length N if...! listlen ( [ ], 0 ).! listlen ( L, N )! listlen ( [ H T ], N ) :- listlen ( T, N1 ), N is N1 + 1.! > On searching for
Accumulators More on Arithmetic and Recursion. Acc-1
Accumulators More on Arithmetic and Recursion Acc-1 listlen(l,n) 1 L is a list of length N if... listlen( [], 0 ). listlen( [ H T ], N ) :- listlen( T, N1 ), N is N1 + 1.» On searching for the goal, the
Logic Programming. Efficiency Issues. Temur Kutsia
Logic Programming Efficiency Issues Temur Kutsia Research Institute for Symbolic Computation Johannes Kepler University of Linz, Austria kutsia@risc.uni-linz.ac.at Efficiency Issues in Prolog Narrow the
10 Recursive Programming in Prolog
10 Recursive Programming in Prolog What's in This Set of Notes? Examples Transforming Recursion to Iteration Recursive Comparison Joining Structures Accumulators Mapping Problems 10.1 Examples select_first(x,xs,ys)
Programming Paradigms
PP 2017/18 Unit 9 Prolog: Accumulators, Order of Goals/Clauses, and the Cut 1/38 Programming Paradigms Unit 9 Prolog: Accumulators, Order of Goals/Clauses, and the Cut J. Gamper Free University of Bozen-Bolzano
Introduction. CSc 372. Comparative Programming Languages. 22 : Prolog Lists. Department of Computer Science University of Arizona.
CSc 372 Comparative Programming Languages 22 : Prolog Lists Introduction Department of Computer Science University of Arizona collberg@gmail.com Copyright c 2011 Christian Collberg Christian Collberg Prolog
Logic Programming. Manipulating Programs. Temur Kutsia
Logic Programming Manipulating Programs Temur Kutsia Research Institute for Symbolic Computation Johannes Kepler University of Linz, Austria kutsia@risc.uni-linz.ac.at Contents Listing Writing Prolog Interpreter
Announcements. Project 5 is on the street. Second part is essay questions for CoS teaming requirements.
Announcements Project 5 is on the street. Second part is essay questions for CoS teaming requirements. The first part you do as a team The CoS essay gets individually answered and has separate submission
Connection between Lists and Terms. Prolog-Lecture 2. Unifying Lists. Unifying Lists. Steps to a Recursive Predicate. List Predicates.
Prolog-Lecture 2 Iqbal Mohomed Connection between Lists and Terms [H T] is just syntactic sugaring for the term.(h,t)?-.(h,t) = [a,b,c]. H = a T = [b, c] ; The dot operator or functor. corresponds to cons
Lecture 11: Feb. 10, 2016
CS323: AI (Hands on with Prolog) Spring 2016 Lecturer: K.R. Chowdhary Lecture 11: Feb. 10, 2016 : Professor of CS (VF) Disclaimer: These notes have not been subjected to the usual scrutiny reserved for
Exercises on the Fundamentals of Prolog
1 Introduction Exercises on the Fundamentals of Prolog These exercises are intended to help reinforce material taught in the lectures of CIS335 course in Prolog. They do not contribute any marks to the
COMP2411 Lecture 20: Logic Programming Examples. (This material not in the book)
COMP2411 Lecture 20: Logic Programming Examples (This material not in the book) There are several distinct but often equivalent ways to think about logic programs 1. As computing logical consequences of
MORE RECURSIVE FUNCTIONS
MORE RECURSIVE FUNCTIONS We'll write a few more recursive functions, just to get in the habit a bit more. After all, recursion being the only looping construct that exists in Erlang (except list comprehensions),
What is a Logic Program. Introduction to Logic Programming. Introductory Examples. Introductory Examples. Foundations, First-Order Language
What is a Logic Program Introduction to Logic Programming Foundations, First-Order Language Temur Kutsia Research Institute for Symbolic Computation Johannes Kepler University Linz, Austria kutsia@risc.jku.at
Lecture 6: More Lists
Lecture 6: More Lists Theory Define append/3, a predicate for concatenating two lists, and illustrate what can be done with it Discuss two ways of reversing a list A naïve way using append/3 A more efficient
3 Lists. List Operations (I)
3 Lists. List Operations (I) The list is the simplest yet the most useful Prolog structure. A list is a sequence of any number of objects. Example 3.1: L = [1, 2, 3], R = [a, b, c], T = [john, marry, tim,
Introduction to Logic Programming
Introduction to Logic Programming Foundations, First-Order Language Temur Kutsia RISC, Johannes Kepler University Linz, Austria kutsia@risc.jku.at What is a Logic Program Logic program is a set of certain
Wan Hussain Wan Ishak
September 1 st Session 2014/2015 (A141) Wan Hussain Wan Ishak School of Computing UUM College of Arts and Sciences Universiti Utara Malaysia (P) 04-9285150 (E) hussain@uum.edu.my (U) http://wanhussain.com
And Parallelism. Parallelism in Prolog. OR Parallelism
Parallelism in Prolog And Parallelism One reason that Prolog is of interest to computer scientists is that its search mechanism lends itself to parallel evaluation. In fact, it supports two different kinds
CSCE 314 Programming Languages
CSCE 314 Programming Languages Haskell: Higher-order Functions Dr. Hyunyoung Lee 1 Higher-order Functions A function is called higher-order if it takes a function as an argument or returns a function as
Shell CSCE 314 TAMU. Higher Order Functions
1 CSCE 314: Programming Languages Dr. Dylan Shell Higher Order Functions 2 Higher-order Functions A function is called higher-order if it takes a function as an argument or returns a function as a result.
Class 2 Recursion on Lists
Class 2 Recursion on Lists The list data type Recursive methods on lists 2014-15 MSc Workshop S.Kamin, U.S.Reddy 1B - Lists - 1 Data structures Contain large amounts of data Allow for access to that data
Logic Programming. Backtracking and Cut. Temur Kutsia
Logic Programming Backtracking and Cut Temur Kutsia Research Institute for Symbolic Computation Johannes Kepler University of Linz, Austria kutsia@risc.uni-linz.ac.at Contents Generating Multiple Solutions
Lecture 9: A closer look at terms
Lecture 9: A closer look at terms Theory Introduce the == predicate Take a closer look at term structure Introduce strings in Prolog Introduce operators Exercises Exercises of LPN: 9.1, 9.2, 9.3, 9.4,
Lecture 5: Declarative Programming. The Declarative Kernel Language Machine. September 12th, 2011
Lecture 5: Declarative Programming. The Declarative Kernel Language Machine September 12th, 2011 1 Lecture Outline Declarative Programming contd Dataflow Variables contd Expressions and Statements Functions
Logic Programming. Prolog as Language. Temur Kutsia
Logic Programming Prolog as Language Temur Kutsia Research Institute for Symbolic Computation Johannes Kepler University Linz, Austria kutsia@risc.jku.at Prolog as Language Syntax Operators Equality Arithmetic
User-defined Functions. Conditional Expressions in Scheme
User-defined Functions The list (lambda (args (body s to a function with (args as its argument list and (body as the function body. No quotes are needed for (args or (body. (lambda (x (+ x 1 s to the increment
Lisp. Versions of LISP
Lisp Versions of LISP Lisp is an old language with many variants Lisp is alive and well today Most modern versions are based on Common Lisp LispWorks is based on Common Lisp Scheme is one of the major
Prolog. Intro to Logic Programming
Prolog Logic programming (declarative) Goals and subgoals Prolog Syntax Database example rule order, subgoal order, argument invertibility, backtracking model of execution, negation by failure, variables
15 212: Principles of Programming. Some Notes on Continuations
15 212: Principles of Programming Some Notes on Continuations Michael Erdmann Spring 2011 These notes provide a brief introduction to continuations as a programming technique. Continuations have a rich
Programming Paradigms
PP 2016/17 Unit 5 Recursion 1/32 Programming Paradigms Unit 5 Recursion J. Gamper Free University of Bozen-Bolzano Faculty of Computer Science IDSE PP 2016/17 Unit 5 Recursion 2/32 Outline 1 Recursion
Principles of Programming Languages Topic: Functional Programming Professor L. Thorne McCarty Spring 2003
Principles of Programming Languages Topic: Functional Programming Professor L. Thorne McCarty Spring 2003 CS 314, LS, LTM: Functional Programming 1 Scheme A program is an expression to be evaluated (in
Information Systems. Relational Databases. Nikolaj Popov
Information Systems Relational Databases Nikolaj Popov Research Institute for Symbolic Computation Johannes Kepler University of Linz, Austria popov@risc.uni-linz.ac.at Outline The Relational Model (Continues
Tuples. CMSC 330: Organization of Programming Languages. Examples With Tuples. Another Example
CMSC 330: Organization of Programming Languages OCaml 2 Higher Order Functions Tuples Constructed using (e1,..., en) Deconstructed using pattern matching Patterns involve parens and commas, e.g., (p1,p2,
Intermediate representations IR #1: CPS/L 3. Code example. Advanced Compiler Construction Michel Schinz
Intermediate representations Intermediate representations Advanced Compiler Construction Michel Schinz 2016 03 03 The term intermediate representation (IR) or intermediate language designates the data-structure(s)
Advanced Prolog Programming
1 Introduction CIS335, Assignment 4 Advanced Prolog Programming Geraint Wiggins November 12, 2004 This practical is the second self-assessed exercise for MSc students on the Prolog module. It is intended
Derived from PROgramming in LOGic (1972) Prolog and LISP - two most popular AI languages. Prolog programs based on predicate logic using Horn clauses
Prolog Programming Derived from PROgramming in LOGic (1972) Good at expressing logical relationships between concepts Prolog and LISP - two most popular AI languages Execution of a Prolog program is a
Association Rule Mining
Association Rule Mining Generating assoc. rules from frequent itemsets Assume that we have discovered the frequent itemsets and their support How do we generate association rules? Frequent itemsets: {1}
Functional Programming in Haskell Part I : Basics
Functional Programming in Haskell Part I : Basics Madhavan Mukund Chennai Mathematical Institute 92 G N Chetty Rd, Chennai 600 017, India madhavan@cmi.ac.in http://www.cmi.ac.in/ madhavan Madras Christian
Repetition Through Recursion
Fundamentals of Computer Science I (CS151.02 2007S) Repetition Through Recursion Summary: In many algorithms, you want to do things again and again and again. For example, you might want to do something
2.2 Graphs Of Functions. Copyright Cengage Learning. All rights reserved.
2.2 Graphs Of Functions Copyright Cengage Learning. All rights reserved. Objectives Graphing Functions by Plotting Points Graphing Functions with a Graphing Calculator Graphing Piecewise Defined Functions
An Explicit-Continuation Metacircular Evaluator
Computer Science (1)21b (Spring Term, 2018) Structure and Interpretation of Computer Programs An Explicit-Continuation Metacircular Evaluator The vanilla metacircular evaluator gives a lot of information
Functional programming with Common Lisp
Functional programming with Common Lisp Dr. C. Constantinides Department of Computer Science and Software Engineering Concordia University Montreal, Canada August 11, 2016 1 / 81 Expressions and functions
Topic B: Backtracking and Lists
Topic B: Backtracking and Lists 1 Recommended Exercises and Readings From Programming in Prolog (5 th Ed.) Readings: Chapter 3 2 Searching for the Answer In order for a Prolog program to report the correct
Forward Recursion. Programming Languages and Compilers (CS 421) Mapping Recursion. Forward Recursion: Examples. Folding Recursion.
Forward Recursion Programming Languages and Compilers (CS 421) Elsa L Gunter 2112 SC, UIUC http://www.cs.uiuc.edu/class/cs421/ Based in part on slides by Mattox Beckman, as updated by Vikram Adve and Gul
Warm-up and Memoization
CSE341 Spring 05 Due Wednesday, May 11 Assignment 4 Part I Warm-up and Memoization Warm-up As a warm-up, write the following Scheme functions: 1. Write the function foldl of the form (foldl func initial
Combining Lists & Built-in Predicates
Combining Lists & Built-in Predicates Artificial Intelligence Programming in Prolog Lecturer: Tim Smith Lecture 6 11/10/04 11/10/04 AIPP Lecture 6: Built-in Predicates 1 Collecting Results Last time we
COP4020 Programming Languages. Logical programming with Prolog Prof. Xin Yuan
COP4020 Programming Languages Logical programming with Prolog Prof. Xin Yuan Topics Logic programming with Prolog COP4020 Spring 2013 2 Definitions: Prolog Terms Terms are symbolic expressions that are
Defining Functions. CSc 372. Comparative Programming Languages. 5 : Haskell Function Definitions. Department of Computer Science University of Arizona
Defining Functions CSc 372 Comparative Programming Languages 5 : Haskell Function Definitions Department of Computer Science University of Arizona collberg@gmail.com When programming in a functional language
Code Generation. The Main Idea of Today s Lecture. We can emit stack-machine-style code for expressions via recursion. Lecture Outline.
The Main Idea of Today s Lecture Code Generation We can emit stack-machine-style code for expressions via recursion (We will use MIPS assembly as our target language) 2 Lecture Outline What are stack machines?
We can emit stack-machine-style code for expressions via recursion
Code Generation The Main Idea of Today s Lecture We can emit stack-machine-style code for expressions via recursion (We will use MIPS assembly as our target language) 2 Lecture Outline What are stack machines?
Last lecture CMSC330. This lecture. Finite Automata: States. Finite Automata. Implementing Regular Expressions. Languages. Regular expressions
Last lecture CMSC330 Finite Automata Languages Sets of strings Operations on languages Regular expressions Constants Operators Precedence 1 2 Finite automata States Transitions Examples Types This lecture
Chapter 6. Predefined Predicates
Advanced Logic Programming https://sewiki.iai.uni-bonn.de/teaching/lectures/alp/2017/ Chapter 6. Predefined Predicates Updated: 12 June, 2017 Reorganized entire chapter Input and output Exception handling
CPL 2016, week 10. Clojure functional core. Oleg Batrashev. April 11, Institute of Computer Science, Tartu, Estonia
CPL 2016, week 10 Clojure functional core Oleg Batrashev Institute of Computer Science, Tartu, Estonia April 11, 2016 Overview Today Clojure language core Next weeks Immutable data structures Clojure simple
Functional Programming in Haskell Prof. Madhavan Mukund and S. P. Suresh Chennai Mathematical Institute
Functional Programming in Haskell Prof. Madhavan Mukund and S. P. Suresh Chennai Mathematical Institute Module # 02 Lecture - 03 Characters and Strings So, let us turn our attention to a data type we have
Generative and accumulative recursion. What is generative recursion? Example revisited: GCD. Readings: Sections 25, 26, 27, 30, 31
Generative and accumulative recursion Readings: Sections 25, 26, 27, 30, 31 Some subsections not explicitly covered in lecture Section 27.2 technique applied to strings CS 135 Fall 2017 11: Generative
9/19/12. Why Study Discrete Math? What is discrete? Sets (Rosen, Chapter 2) can be described by discrete math TOPICS
What is discrete? Sets (Rosen, Chapter 2) TOPICS Discrete math Set Definition Set Operations Tuples Consisting of distinct or unconnected elements, not continuous (calculus) Helps us in Computer Science
Forward recursion. CS 321 Programming Languages. Functions calls and the stack. Functions calls and the stack
Forward recursion CS 321 Programming Languages Intro to OCaml Recursion (tail vs forward) Baris Aktemur Özyeğin University Last update made on Thursday 12 th October, 2017 at 11:25. Much of the contents
Functions. Copyright Cengage Learning. All rights reserved.
Functions Copyright Cengage Learning. All rights reserved. 2.2 Graphs Of Functions Copyright Cengage Learning. All rights reserved. Objectives Graphing Functions by Plotting Points Graphing Functions with
Conjunctive queries. Many computational problems are much easier for conjunctive queries than for general first-order queries.
Conjunctive queries Relational calculus queries without negation and disjunction. Conjunctive queries have a normal form: ( y 1 ) ( y n )(p 1 (x 1,..., x m, y 1,..., y n ) p k (x 1,..., x m, y 1,..., y
IKI30820 Logic Programming Programming Style and Techniques Slide 09
IKI30820 Logic Programming Programming Style and Techniques Slide 09 Ari Saptawijaya (slides) Adila A. Krisnadhi (L A T E Xadaptation) Fakultas Ilmu Komputer Universitas Indonesia 2009/2010 Semester Gasal
The object level in Prolog. Meta-level predicates and operators. Contents. The flow of computation. The meta level in Prolog
Lecture 8 Meta-level predicates and operators Contents Object level vs. meta level Controlling flow of computation Checking and dismantling expressions Comparison operators The object level in Prolog Prolog
LISP. Everything in a computer is a string of binary digits, ones and zeros, which everyone calls bits.
LISP Everything in a computer is a string of binary digits, ones and zeros, which everyone calls bits. From one perspective, sequences of bits can be interpreted as a code for ordinary decimal digits,
Lecture 3: Recursion; Structural Induction
15-150 Lecture 3: Recursion; Structural Induction Lecture by Dan Licata January 24, 2012 Today, we are going to talk about one of the most important ideas in functional programming, structural recursion
Week - 04 Lecture - 01 Merge Sort. (Refer Slide Time: 00:02)
Programming, Data Structures and Algorithms in Python Prof. Madhavan Mukund Department of Computer Science and Engineering Indian Institute of Technology, Madras Week - 04 Lecture - 01 Merge Sort (Refer
Chapter 1. Fundamentals of Higher Order Programming
Chapter 1 Fundamentals of Higher Order Programming 1 The Elements of Programming Any powerful language features: so does Scheme primitive data procedures combinations abstraction We will see that Scheme
AI2 Remedial Prolog Tutorial 2
AI2 Remedial Prolog Tutorial 2 Rules The Prolog interpreter is able to make inferences (i.e. reasoning of the form If Alan drinks beer, then he must like it). This is done by way of using rules. There
Recursion & Iteration
Recursion & Iteration York University Department of Computer Science and Engineering 1 Overview Recursion Examples Iteration Examples Iteration vs. Recursion Example [ref.: Chap 5,6 Wilensky] 2 Recursion
Lecture 9. Exercises. Theory. Solutions to exercises LPN 8.1 & 8.2. Patrick Blackburn, Johan Bos & Kristina Striegnitz
Lecture 9 Exercises Solutions to exercises LPN 8.1 & 8.2 Theory Solution to Exercise 8.1 Suppose we add the noun ``men'' (which is plural) and the verb ``shoot''. Then we would want a DCG which says that
Arithmetic Terms are Symbolic
Arithmetic Terms are Symbolic Evaluation of an arithmetic term into a numeric value must be forced. That is, 1+2 is an infix representation of the relation +(1,2). This term is not an integer! Therefore?-
The Idea Underlying Logic Programming. CSci 8980, Fall 2012 Specifying and Reasoning About Computational Systems An Introduction to Logic Programming
The Idea Underlying CSci 8980, Fall 2012 Specifying and Reasoning About Computational Systems An Introduction to Department of Computer Science and Engineering University of Minnesota Lectures in Fall
CSE P 501 Exam 11/17/05 Sample Solution
1. (8 points) Write a regular expression or set of regular expressions that generate the following sets of strings. You can use abbreviations (i.e., name = regular expression) if it helps to make your
6.001 Notes: Section 31.1
6.001 Notes: Section 31.1 Slide 31.1.1 In previous lectures we have seen a number of important themes, which relate to designing code for complex systems. One was the idea of proof by induction, meaning
A Small Interpreted Language
A Small Interpreted Language What would you need to build a small computing language based on mathematical principles? The language should be simple, Turing equivalent (i.e.: it can compute anything that
CAP 5602 Summer, Lesson 5: Lists. The topics 1. updating a counter 2. the list structure 3. some useful built-in predicates for lists
CAP 5602 Summer, 20 Lesson 5: Lists The topics. updating a counter 2. the list structure 3. some useful built-in predicates for lists. Updating a counter Let us try to implement the increse the counter
PROGRAMMING IN HASKELL. CS Chapter 6 - Recursive Functions
PROGRAMMING IN HASKELL CS-205 - Chapter 6 - Recursive Functions 0 Introduction As we have seen, many functions can naturally be defined in terms of other functions. factorial :: Int Int factorial n product
Parsing Combinators: Introduction & Tutorial
Parsing Combinators: Introduction & Tutorial Mayer Goldberg October 21, 2017 Contents 1 Synopsis 1 2 Backus-Naur Form (BNF) 2 3 Parsing Combinators 3 4 Simple constructors 4 5 The parser stack 6 6 Recursive
A brief tour of history
Introducing Racket λ A brief tour of history We wanted a language that allowed symbolic manipulation Scheme The key to understanding LISP is understanding S-Expressions Racket List of either atoms or
Functional Programming Languages (FPL)
Functional Programming Languages (FPL) 1. Definitions... 2 2. Applications... 2 3. Examples... 3 4. FPL Characteristics:... 3 5. Lambda calculus (LC)... 4 6. Functions in FPLs... 7 7. Modern functional
Programming Paradigms
PP 2016/17 Unit 16 Erlang Modules, Functions and Control Structures 1/31 Programming Paradigms Unit 16 Erlang Modules, Functions and Control Structures J. Gamper Free University of Bozen-Bolzano Faculty
The Art of Recursion: Problem Set 10
The Art of Recursion: Problem Set Due Tuesday, November Tail recursion A recursive function is tail recursive if every recursive call is in tail position that is, the result of the recursive call is immediately
Deductive Databases. Motivation. Datalog. Chapter 25
Deductive Databases Chapter 25 1 Motivation SQL-92 cannot express some queries: Are we running low on any parts needed to build a ZX600 sports car? What is the total component and assembly cost to build
Automated Reasoning Systems
Automated Reasoning Systems Resolution Theorem Proving: Prover9 Temur Kutsia RISC, Johannes Kepler University of Linz, Austria kutsia@risc.uni-linz.ac.at May 11, 2011 Prover9 Automated theorem prover from
Functional Programming. Pure Functional Programming
Functional Programming Pure Functional Programming Computation is largely performed by applying functions to values. The value of an expression depends only on the values of its sub-expressions (if any).
p x i 1 i n x, y, z = 2 x 3 y 5 z
3 Pairing and encoding functions Our aim in this part of the course is to show that register machines can compute everything that can be computed, and to show that there are things that can t be computed.
Ordered structures. Dr. C. Constantinides. Department of Computer Science and Software Engineering Concordia University Montreal, Canada
Ordered structures Dr. C. Constantinides Department of Computer Science and Software Engineering Concordia University Montreal, Canada January 10, 2017 1/19 Introduction Ordered structures include tuples,
simplicity hides complexity flow of control, negation, cut, 2 nd order programming, tail recursion procedural and declarative semantics and & or
simplicity hides complexity flow of control, negation, cut, 2 nd order programming, tail recursion simple and/or composition of goals hides complex control patterns not easily represented by traditional
Booleans (aka Truth Values) Programming Languages and Compilers (CS 421) Booleans and Short-Circuit Evaluation. Tuples as Values.
Booleans (aka Truth Values) Programming Languages and Compilers (CS 421) Elsa L Gunter 2112 SC, UIUC https://courses.engr.illinois.edu/cs421/fa2017/cs421d # true;; - : bool = true # false;; - : bool =
Introduction to Prolog Paper Refs. Prolog tutor. Julian Verdurmen. Seminar Softw. tech. for teaching and learning. September 30, 2009
Seminar Softw. tech. for teaching and learning September 30, 2009 Outline 1 Introduction to Prolog Basics Simple example 2 Basics Simple example Outline 1 Introduction to Prolog Basics Simple example 2
simplicity hides complexity flow of control, negation, cut, 2 nd order programming, tail recursion procedural and declarative semantics and & or
simplicity hides complexity flow of control, negation, cut, 2 nd order programming, tail recursion simple and/or composition of goals hides complex control patterns not easily represented by traditional
Haskell through HUGS THE BASICS
Haskell through HUGS THE BASICS FP for DB Basic HUGS 1 Algorithmic Imperative Languages variables assignment if condition then action1 else action2 loop block while condition do action repeat action until
Programming Languages Third Edition
Programming Languages Third Edition Chapter 12 Formal Semantics Objectives Become familiar with a sample small language for the purpose of semantic specification Understand operational semantics Understand
Computational Logic Prolog Programming Basics
Computational Logic Prolog Programming Basics 1 Overview 1. Using unification 2. Data structures 3. Recursion, backtracking, and search 4. Control of execution 2 Role of Unification in Execution As mentioned
Prolog Programming Basics. Computational Logic. Overview. 3. Recursion, backtracking, and search. 2. Data structures. 1.
Computational Logic Prolog Programming Basics 1 Overview 1. Using unification 2. Data structures 3. Recursion, backtracking, and search 4. Control of execution 2 Role of Unification in Execution As mentioned
An introduction to logic programming with Prolog
An introduction to logic programming with Prolog Dr. Constantinos Constantinides Department of Computer Science and Software Engineering Concordia University A running example: A family genealogy tree
(Provisional) Lecture 08: List recursion and recursive diagrams 10:00 AM, Sep 22, 2017
Integrated Introduction to Computer Science Hughes (Provisional) Lecture 08: List recursion and recursive diagrams 10:00 AM, Sep 22, 2017 Contents 1 Announcements 1 2 Evaluation Correction 1 3 Lists 2
6.001 Notes: Section 8.1
6.001 Notes: Section 8.1 Slide 8.1.1 In this lecture we are going to introduce a new data type, specifically to deal with symbols. This may sound a bit odd, but if you step back, you may realize that everything
Lists in Lisp and Scheme
Lists in Lisp and Scheme a Lists in Lisp and Scheme Lists are Lisp s fundamental data structures, but there are others Arrays, characters, strings, etc. Common Lisp has moved on from being merely a LISt
CSC324 Logic & Relational Programming Illustrated in Prolog
CSC324 Logic & Relational Programming Illustrated in Prolog Afsaneh Fazly 1 Winter 2013 1 with many thanks to Anya Tafliovich, Gerald Penn and Sheila McIlraith. 1 2 admin notes Please check your marks
Memory Addressing, Binary, and Hexadecimal Review
C++ By A EXAMPLE Memory Addressing, Binary, and Hexadecimal Review You do not have to understand the concepts in this appendix to become well-versed in C++. You can master C++, however, only if you spend