Programming Language Concepts: Lecture 22
|
|
|
- Scarlett Hampton
- 6 years ago
- Views:
Transcription
1 Programming Language Concepts: Lecture 22 Madhavan Mukund Chennai Mathematical Institute PLC 2009, Lecture 22, 15 April 2009
2 Logic programming Programming with relations Variables Names starting with a capital letter X, Y, Name,... Constants Names starting with a small letter ball, node, graph, a, b,.... Uninterpreted no types like Char, Bool etc! Exception: natural numbers, some arithmetic
3 Defining relations A Prolog program describes a relation Example: A graph
4 Defining relations A Prolog program describes a relation Example: A graph Want to define a relation path(x,y) path(x,y) holds if there is a path from X to Y
5 Facts and rules Represent edge relation using the following facts. edge(3,4). edge(5,4). edge(5,1). edge(1,2). edge(3,5). edge(2,3).
6 Facts and rules Define path using the following rules. path(x,y) :- X = Y. path(x,y) :- edge(x,z), path(z,y).
7 Facts and rules Define path using the following rules. path(x,y) :- X = Y. path(x,y) :- edge(x,z), path(z,y). Read the rules read as follows: Rule 1 For all X, (X,X) path. Rule 2 For all X,Y, (X,Y) path if there exists Z such that (X,Z) edge and (Z,Y) path.
8 Facts and rules... path(x,y) :- X = Y. path(x,y) :- edge(x,z), path(z,y). Each rule is of the form Conclusion if Premise 1 and Premise 2...and Premise n if is written :- and is written, This type of logical formula is called a Horn Clause Quantification of variables Variables in goal are universally quantified X, Y above Variables in premise are existentially quantified Z above
9 Computing in Prolog Ask a question (a query)?- path(3,1). Prolog scans facts and rules top-to-bottom 3 cannot be unified with 1, skip Rule 1. Rule 2 generates two subgoals. Find Z such that (3,Z) edge and (Z,1) path. Sub goals are tried depth-first (3,Z) edge? (3,4) edge, set Z = 4 (4,1) path? 4 cannot be unifed with 1, two subgoals, new Z (4,Z ) edge (Z,1) path Cannot find Z such that (4,Z ) edge!
10 Backtracking (3,Z) edge? edge(3,4) edge, set Z = 4 (4,1) path? 4 cannot be unified with 1, two subgoals, new Z (4,Z ) edge (Z,1) path No Z such that (4,Z ) edge Backtrack and try another value for Z edge(3,5) edge, set Z = 5 (5,1) path? (5,1) edge, Backtracking is sensitive to order of facts We had put edge(3,4) before edge(3,5)
11 Reversing the question Consider the question?- edge(3,x). Find all X such that (3,X) edge Prolog lists out all satisfying values, one by one X=4; X=5; X=2; No.
12 Unification and pattern matching A goal of the form X = Y denotes unification. path(x,y) :- X = Y. path(x,y) :- edge(x,z), path(z,y).
13 Unification and pattern matching A goal of the form X = Y denotes unification. path(x,y) :- X = Y. path(x,y) :- edge(x,z), path(z,y). Can implicitly represent such goals in the head path(x,x). path(x,y) :- edge(x,z), path(z,y).
14 Unification and pattern matching A goal of the form X = Y denotes unification. path(x,y) :- X = Y. path(x,y) :- edge(x,z), path(z,y). Can implicitly represent such goals in the head path(x,x). path(x,y) :- edge(x,z), path(z,y). Unification provides a formal justification for pattern matching in rule definitions
15 Unification and pattern matching A goal of the form X = Y denotes unification. path(x,y) :- X = Y. path(x,y) :- edge(x,z), path(z,y). Can implicitly represent such goals in the head path(x,x). path(x,y) :- edge(x,z), path(z,y). Unification provides a formal justification for pattern matching in rule definitions Unlike Haskell, a repeated variable in the pattern is meaningful In Haskell, we cannot write path (x,x) = True
16 Complex data and terms Represent arbitrary structures with nested terms A record or struct of the form personal_data{ name : amit date_of_birth{ year : 1980 month : 5 day : 30 } }
17 Complex data and terms Represent arbitrary structures with nested terms A record or struct of the form personal_data{ name : amit date_of_birth{ year : 1980 month : 5 day : 30 } }...can be represented by a term personal_data(name(amit), date_of_birth(year(1980),month(5),day(30)))
18 Lists Write [Head Tail] for Haskell s (head:tail)
19 Lists Write [Head Tail] for Haskell s (head:tail) [] denotes the emptylist
20 Lists Write [Head Tail] for Haskell s (head:tail) [] denotes the emptylist No types, so lists need not be homogeneous!
21 Lists Write [Head Tail] for Haskell s (head:tail) [] denotes the emptylist No types, so lists need not be homogeneous! Checking membership in a list member(x,[y T]) :- X = Y. member(x,[y T]) :- member(x,t).
22 Lists Write [Head Tail] for Haskell s (head:tail) [] denotes the emptylist No types, so lists need not be homogeneous! Checking membership in a list member(x,[y T]) :- X = Y. member(x,[y T]) :- member(x,t). Use patterns instead of explicit unification member(x,[x T]). member(x,[h T]) :- member(x,t).
23 Lists Write [Head Tail] for Haskell s (head:tail) [] denotes the emptylist No types, so lists need not be homogeneous! Checking membership in a list member(x,[y T]) :- X = Y. member(x,[y T]) :- member(x,t). Use patterns instead of explicit unification member(x,[x T]). member(x,[h T]) :- member(x,t).... plus anonymous variables. member(x,[x _]). member(x,[_ T]) :- member(x,t).
24 Lists... Appending two lists
25 Lists... Appending two lists append(x,y,[x Y]). will not work
26 Lists... Appending two lists append(x,y,[x Y]). will not work append([1,2],[a,b],z] yields Z = [[1,2],a,b]
27 Lists... Appending two lists append(x,y,[x Y]). will not work append([1,2],[a,b],z] yields Z = [[1,2],a,b] Inductive definition, like Haskell append(xs, Ys, Zs) :- Xs = [], Zs = Ys. append(xs, Ys, Zs) :- Xs = [H Ts], Zs = [H Us], append(ts, Ys, Us).
28 Lists... Appending two lists append(x,y,[x Y]). will not work append([1,2],[a,b],z] yields Z = [[1,2],a,b] Inductive definition, like Haskell append(xs, Ys, Zs) :- Xs = [], Zs = Ys. append(xs, Ys, Zs) :- Xs = [H Ts], Zs = [H Us], append(ts, Ys, Us). Again, eliminate explicit unification append([], Ys, Ys). append([x Xs], Ys, [X Zs]) :- append(xs, Ys, Zs).
29 Reversing the computation?- append(xs, Ys, [mon, wed, fri]).
30 Reversing the computation?- append(xs, Ys, [mon, wed, fri]). All possible ways to split the list
31 Reversing the computation?- append(xs, Ys, [mon, wed, fri]). All possible ways to split the list Xs = [] Ys = [mon, wed, fri] ; Xs = [mon] Ys = [wed, fri] ; Xs = [mon, wed] Ys = [fri] ; Xs = [mon, wed, fri] Ys = [] ; no
32 Reversing the computation... Want to define a relation sublist(xs,ys) Xs Ys
33 Reversing the computation... Want to define a relation sublist(xs,ys) Xs Ys Add an intermediate list Zs Xs Zs Ys
34 Reversing the computation... Want to define a relation sublist(xs,ys) Xs Ys Add an intermediate list Zs Xs Zs Ys Yields the rule sublist(xs, Ys) :- append(_, Zs, Ys), append(xs, _, Zs).
35 Reversing the computation... Want to define a relation sublist(xs,ys) Xs Ys Add an intermediate list Zs Xs Zs Ys Yields the rule sublist(xs, Ys) :- append(_, Zs, Ys), append(xs, _, Zs). Why won t the following work? sublist(xs, Ys) :- append(xs, _, Zs), append(_, Zs, Ys).
36 Reversing the computation... Type inference for simply typed lambda calculus x Var λx.m MN
37 Reversing the computation... Type inference for simply typed lambda calculus x Var λx.m MN Inference rules to derive type judgments of the form A M : s A is list {xi : t i } of type assumptions for variables Under the assumptions in A the expression M has type s.
38 Reversing the computation... Type inference for simply typed lambda calculus x Var λx.m MN Inference rules to derive type judgments of the form A M : s A is list {xi : t i } of type assumptions for variables Under the assumptions in A the expression M has type s. x : t A A x : t A M : s t, A N : s A (MN) : t A + x : s M : t A (λx.m) : s t
39 Reversing the computation... Encoding λ-calculus and types in Prolog var(x) for variable x (Note: x is a constant!) lambda(x,m) for λx.m apply(m,n) for MN arrow(s,t) for s t
40 Reversing the computation... Encoding λ-calculus and types in Prolog var(x) for variable x (Note: x is a constant!) lambda(x,m) for λx.m apply(m,n) for MN arrow(s,t) for s t Type inference in Prolog % type(a, S, T):- lambda term S has type T in the environment A. type(a, var(x), T):- member([x, T], A). type(a, apply(m, N), T):- type(a, M, arrow(s,t), type(a, N, S). type(a, lambda(x, M), (arrow(s,t)):- type([[x, S] A], M, T).
41 Reversing the computation... Encoding λ-calculus and types in Prolog var(x) for variable x (Note: x is a constant!) lambda(x,m) for λx.m apply(m,n) for MN arrow(s,t) for s t Type inference in Prolog % type(a, S, T):- lambda term S has type T in the environment A. type(a, var(x), T):- member([x, T], A). type(a, apply(m, N), T):- type(a, M, arrow(s,t), type(a, N, S). type(a, lambda(x, M), (arrow(s,t)):- type([[x, S] A], M, T).?- type([],t,t). asks if term t is typable.?- type([], lambda(x, apply(var(x), var(x))), T).
42 Reversing the computation... Encoding λ-calculus and types in Prolog var(x) for variable x (Note: x is a constant!) lambda(x,m) for λx.m apply(m,n) for MN arrow(s,t) for s t Type inference in Prolog % type(a, S, T):- lambda term S has type T in the environment A. type(a, var(x), T):- member([x, T], A). type(a, apply(m, N), T):- type(a, M, arrow(s,t), type(a, N, S). type(a, lambda(x, M), (arrow(s,t)):- type([[x, S] A], M, T).?- type([],t,t). asks if term t is typable.?- type([], lambda(x, apply(var(x), var(x))), T). type([[x, S]], apply(var(x), var(x)), T)
43 Reversing the computation... Encoding λ-calculus and types in Prolog var(x) for variable x (Note: x is a constant!) lambda(x,m) for λx.m apply(m,n) for MN arrow(s,t) for s t Type inference in Prolog % type(a, S, T):- lambda term S has type T in the environment A. type(a, var(x), T):- member([x, T], A). type(a, apply(m, N), T):- type(a, M, arrow(s,t), type(a, N, S). type(a, lambda(x, M), (arrow(s,t)):- type([[x, S] A], M, T).?- type([],t,t). asks if term t is typable.?- type([], lambda(x, apply(var(x), var(x))), T). type([[x, S]], apply(var(x), var(x)), T) type([[x, S]], var(x), arrow(s,t)).
44 Reversing the computation... Encoding λ-calculus and types in Prolog var(x) for variable x (Note: x is a constant!) lambda(x,m) for λx.m apply(m,n) for MN arrow(s,t) for s t Type inference in Prolog % type(a, S, T):- lambda term S has type T in the environment A. type(a, var(x), T):- member([x, T], A). type(a, apply(m, N), T):- type(a, M, arrow(s,t), type(a, N, S). type(a, lambda(x, M), (arrow(s,t)):- type([[x, S] A], M, T).?- type([],t,t). asks if term t is typable.?- type([], lambda(x, apply(var(x), var(x))), T). type([[x, S]], apply(var(x), var(x)), T) type([[x, S]], var(x), arrow(s,t)). member([x, arrow(s,t)], [[x, S]])
45 Reversing the computation... Encoding λ-calculus and types in Prolog var(x) for variable x (Note: x is a constant!) lambda(x,m) for λx.m apply(m,n) for MN arrow(s,t) for s t Type inference in Prolog % type(a, S, T):- lambda term S has type T in the environment A. type(a, var(x), T):- member([x, T], A). type(a, apply(m, N), T):- type(a, M, arrow(s,t), type(a, N, S). type(a, lambda(x, M), (arrow(s,t)):- type([[x, S] A], M, T).?- type([],t,t). asks if term t is typable.?- type([], lambda(x, apply(var(x), var(x))), T). type([[x, S]], apply(var(x), var(x)), T) type([[x, S]], var(x), arrow(s,t)). member([x, arrow(s,t)], [[x, S]]) Unification fails
46 Example: special sequence... Arrange three 1s, three 2s,..., three 9s in sequence so that for all i [1..9] there are exactly i numbers between successive occurrences of i
47 Example: special sequence... Arrange three 1s, three 2s,..., three 9s in sequence so that for all i [1..9] there are exactly i numbers between successive occurrences of i 1,9,1,2,1,8,2,4,6,2, 7, 9, 4,5,8,6,3, 4, 7, 5,3,9,6,8, 3, 5, 7.
48 Example: special sequence... Arrange three 1s, three 2s,..., three 9s in sequence so that for all i [1..9] there are exactly i numbers between successive occurrences of i 1,9,1,2,1,8,2,4,6,2, 7, 9, 4,5,8,6,3, 4, 7, 5,3,9,6,8, 3, 5, 7. % sequence(xs) :- Xs is a list of 27 variables. sequence([_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_]).
49 Example: special sequence... Arrange three 1s, three 2s,..., three 9s in sequence so that for all i [1..9] there are exactly i numbers between successive occurrences of i 1,9,1,2,1,8,2,4,6,2, 7, 9, 4,5,8,6,3, 4, 7, 5,3,9,6,8, 3, 5, 7. % sequence(xs) :- Xs is a list of 27 variables. sequence([_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_]). solution(ss) :- sequence(ss), sublist([9,_,_,_,_,_,_,_,_,_,9,_,_,_,_,_,_,_,_,_,9], Ss), sublist([8,_,_,_,_,_,_,_,_,8,_,_,_,_,_,_,_,_,8], Ss), sublist([7,_,_,_,_,_,_,_,7,_,_,_,_,_,_,_,7], Ss), sublist([6,_,_,_,_,_,_,6,_,_,_,_,_,_,6], Ss), sublist([5,_,_,_,_,_,5,_,_,_,_,_,5], Ss), sublist([4,_,_,_,_,4,_,_,_,_,4], Ss), sublist([3,_,_,_,3,_,_,_,3], Ss), sublist([2,_,_,2,_,_,2], Ss), sublist([1,_,1,_,1], Ss).
50 Arithmetic Computing length of a list length([],0). length([h,t],n) :- length(t,m), N = M+1.
51 Arithmetic Computing length of a list length([],0). length([h,t],n) :- length(t,m), N = M+1. What does the following query yield??- length([1,2,3,4],n).
52 Arithmetic Computing length of a list length([],0). length([h,t],n) :- length(t,m), N = M+1. What does the following query yield??- length([1,2,3,4],n). N= X = Y is unification
53 Arithmetic Computing length of a list length([],0). length([h,t],n) :- length(t,m), N = M+1. What does the following query yield??- length([1,2,3,4],n). N= X = Y is unification X is Y captures arithmetic equality
54 Arithmetic Computing length of a list length([],0). length([h,t],n) :- length(t,m), N = M+1. What does the following query yield??- length([1,2,3,4],n). N= X = Y is unification X is Y captures arithmetic equality length([],0). length([h,t],n) :- length(t,m), N is M+1.
55 Arithmetic... Another approach length(l,n) :- auxlength(l,0,n). auxlength([],n,n). auxlength([h T],M,N) :- auxlength(t,m1,n), M1 is M+1.
56 Arithmetic... Another approach length(l,n) :- auxlength(l,0,n). auxlength([],n,n). auxlength([h T],M,N) :- auxlength(t,m1,n), M1 is M+1.?- length([0,1,2],n) generates goals auxlength([0,1,2],0,n)
57 Arithmetic... Another approach length(l,n) :- auxlength(l,0,n). auxlength([],n,n). auxlength([h T],M,N) :- auxlength(t,m1,n), M1 is M+1.?- length([0,1,2],n) generates goals auxlength([0,1,2],0,n) auxlength([1,2],1,n)
58 Arithmetic... Another approach length(l,n) :- auxlength(l,0,n). auxlength([],n,n). auxlength([h T],M,N) :- auxlength(t,m1,n), M1 is M+1.?- length([0,1,2],n) generates goals auxlength([0,1,2],0,n) auxlength([1,2],1,n) auxlength([2],2,n)
59 Arithmetic... Another approach length(l,n) :- auxlength(l,0,n). auxlength([],n,n). auxlength([h T],M,N) :- auxlength(t,m1,n), M1 is M+1.?- length([0,1,2],n) generates goals auxlength([0,1,2],0,n) auxlength([1,2],1,n) auxlength([2],2,n) auxlength([],3,n)
60 Arithmetic... Another approach length(l,n) :- auxlength(l,0,n). auxlength([],n,n). auxlength([h T],M,N) :- auxlength(t,m1,n), M1 is M+1.?- length([0,1,2],n) generates goals auxlength([0,1,2],0,n) auxlength([1,2],1,n) auxlength([2],2,n) auxlength([],3,n) auxlength([],3,3)
61 Arithmetic... Another approach length(l,n) :- auxlength(l,0,n). auxlength([],n,n). auxlength([h T],M,N) :- auxlength(t,m1,n), M1 is M+1.?- length([0,1,2],n) generates goals auxlength([0,1,2],0,n) auxlength([1,2],1,n) auxlength([2],2,n) auxlength([],3,n) auxlength([],3,3) Second argument to auxlength accumulates answer.
62 Coping with circular definitions edge(g,h). edge(d,a). edge(g,d). edge(e,d). edge(h,f). edge(e,f). edge(a,e). edge(a,b). edge(b,f). edge(b,c). edge(f,c). d a e g b f h c path(x,x). path(x,y) :- edge(x,z), path(z,y).
63 Coping with circular definitions edge(g,h). edge(d,a). edge(g,d). edge(e,d). edge(h,f). edge(e,f). edge(a,e). edge(a,b). edge(b,f). edge(b,c). edge(f,c). d a e g b f h c path(x,x). path(x,y) :- edge(x,z), path(z,y). What does?- path(a,b) compute?
64 Coping with circularity... Instead path(x,x,t). path(x,y,t) :- a(x,z), legal(z,t), path(z,y,[z T]). legal(z,[]). legal(z,[h T]) :- Z\==H, legal(z,t). path(x,y,t) succeeds if there is a path from X to Y that does not visit any nodes in T T is an accumulator
Logic Programming: Lecture 1
Logic Programming: Lecture 1 Madhavan Mukund Chennai Mathematical Institute madhavan@cmi.ac.in PLC, 3 April 2017 Logic programming Programming with relations Variables Names starting with a capital letter
Programming Language Concepts: Lecture 19
Programming Language Concepts: Lecture 19 Madhavan Mukund Chennai Mathematical Institute madhavan@cmi.ac.in http://www.cmi.ac.in/~madhavan/courses/pl2009 PLC 2009, Lecture 19, 01 April 2009 Adding types
Programming Language Concepts: Lecture 14
Programming Language Concepts: Lecture 14 Madhavan Mukund Chennai Mathematical Institute madhavan@cmi.ac.in http://www.cmi.ac.in/~madhavan/courses/pl2009 PLC 2009, Lecture 14, 11 March 2009 Function programming
Introduction to Programming, Aug-Dec 2006
Introduction to Programming, Aug-Dec 2006 Lecture 3, Friday 11 Aug 2006 Lists... We can implicitly decompose a list into its head and tail by providing a pattern with two variables to denote the two components
Chapter 5. Pure PROLOG. Foundations of Logic Programming
Chapter 5 1 Outline vs. logic programming Lists in Adding Arithmetics to Adding the Cut to 2 Syntax of Pure Prolog p(x,a) :- q(x), r(x,yi). p(x, a) q(x), r(x,y i ) % Comment Ambivalent syntax: p(p(a,b),
Lecture 16: Logic Programming in Prolog
Lecture 16: Logic Programming in Prolog COMP 524 Programming Language Concepts Stephen Olivier March 26, 2009 Based on slides by A. Block, notes by N. Fisher, F. Hernandez-Campos, and D. Stotts Goal of
Chapter 16. Logic Programming. Topics. Unification. Resolution. Prolog s Search Strategy. Prolog s Search Strategy
Topics Chapter 16 Logic Programming Summary (resolution, unification, Prolog search strategy ) Disjoint goals The cut operator Negative goals Predicate fail Debugger / tracer Lists 2 Resolution Resolution
Week 5 Tutorial Structural Induction
Department of Computer Science, Australian National University COMP2600 / COMP6260 Formal Methods in Software Engineering Semester 2, 2016 Week 5 Tutorial Structural Induction You should hand in attempts
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
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
CS 360: Programming Languages Lecture 10: Logic Programming with Prolog
CS 360: Programming Languages Lecture 10: Logic Programming with Prolog Geoffrey Mainland Drexel University Section 1 Administrivia Midterm Tuesday Midterm is Tuesday, February 14! Study guide is on the
Logic Programming. CITS 3242 Programming Paradigms. Topic 16: Part IV: Advanced Topics
CITS 3242 Programming Paradigms Part IV: Advanced Topics Topic 16: Logic Programming Logic Programming is a paradigm for programming by declaring facts and rules. Programs are executed by querying whether
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
Example problems. Combinatorial auction. Towers of Hanoi Rectangle packing Shortest route. 8 queens Soduko Maximizing (minimizing) costs
FunLog Example problems Combinatorial auction sell all the items Towers of Hanoi Rectangle packing Shortest route. 8 queens Soduko Maximizing (minimizing) costs Finding a solution with given property 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
CSE 3302 Programming Languages Lecture 8: Functional Programming
CSE 3302 Programming Languages Lecture 8: Functional Programming (based on the slides by Tim Sheard) Leonidas Fegaras University of Texas at Arlington CSE 3302 L8 Spring 2011 1 Functional Programming Languages
CS 320: Concepts of Programming Languages
CS 320: Concepts of Programming Languages Wayne Snyder Computer Science Department Boston University Lecture 04: Basic Haskell Continued o Polymorphic Types o Type Inference with Polymorphism o Standard
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
Lambda Calculus and Type Inference
Lambda Calculus and Type Inference Björn Lisper Dept. of Computer Science and Engineering Mälardalen University bjorn.lisper@mdh.se http://www.idt.mdh.se/ blr/ October 13, 2004 Lambda Calculus and Type
815338A Principles of Programming Languages. Exercise 7 answers
815338A Principles of Programming Languages. Exercise 7 answers The topic of this exercise is logic programming in Prolog. Prolog programs can be executed at https://ideone.com/ or http://www.tutorialspoint.com/codingground.htm.
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
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
Programming in Haskell Aug-Nov 2015
Programming in Haskell Aug-Nov 2015 LECTURE 14 OCTOBER 1, 2015 S P SURESH CHENNAI MATHEMATICAL INSTITUTE Enumerated data types The data keyword is used to define new types data Bool = False True data Day
CS 360: Programming Language Concepts Lecture 15 Logic Programming
Reference: Ch. 12.1-12.5 CS 360: Programming Language Concepts Lecture 15 Logic Programming I. Logic Programming (Generally) What is logic programming? A logic program is a collection of declarations,
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
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,
QUTE: A PROLOG/LISP TYPE LANGUAGE FOR LOGIC PROGRAMMING
QUTE: A PROLOG/LISP TYPE LANGUAGE FOR LOGIC PROGRAMMING Masahiko Sato Takafumi Sakurai Department of Information Science, Faculty of Science University of Tokyo 7-3-1 Hongo, Bunkyo-ku, Tokyo 113, JAPAN
The List Datatype. CSc 372. Comparative Programming Languages. 6 : Haskell Lists. Department of Computer Science University of Arizona
The List Datatype CSc 372 Comparative Programming Languages 6 : Haskell Lists Department of Computer Science University of Arizona collberg@gmail.com All functional programming languages have the ConsList
Higher Order Functions in Haskell
Higher Order Functions in Haskell Evan Misshula 2018-09-10 Outline Curried Functions Curried comparison Example partial application partial application of a string function Returned functions ZipWith flip
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
Functional Programming. Overview. Topics. Definition n-th Fibonacci Number. Graph
Topics Functional Programming Christian Sternagel Harald Zankl Evgeny Zuenko Department of Computer Science University of Innsbruck WS 2017/2018 abstract data types, algebraic data types, binary search
1 / Types and Programming Languages
1 / 65 263-2200 Types and Programming Languages 2 / 65 Outline Control Flow During Execution Tree Traversal A Detailed Trace Search Space Analysis Modelling Equations and Operations Lists 3 / 65 Outline
CSCE 314 TAMU Fall CSCE 314: Programming Languages Dr. Flemming Andersen. Haskell Functions
1 CSCE 314: Programming Languages Dr. Flemming Andersen Haskell Functions 2 Outline Defining Functions List Comprehensions Recursion 3 Conditional Expressions As in most programming languages, functions
Prolog Programming. Lecture Module 8
Prolog Programming Lecture Module 8 Prolog Language Prolog is unique in its ability to infer facts from the given facts and rules. In Prolog, an order of clauses in the program and goals in the body of
What s the problem? fib(1,1). fib(2,1). fib(n,x) :- N>2, N1 is N-1, N2 is N-2, fib(n1,x2), fib(n2,x2).
39 What s the problem? A Fibonacci Implementation fib(1,1). fib(2,1). fib(n,x) :- N>2, N1 is N-1, N2 is N-2, fib(n1,x2), fib(n2,x2). List Concatenation conc([],l,l). conc([x L1], L2, [X L3]) :- conc(l1,l2,l3).
Module 7. Knowledge Representation and Logic (Rule based Systems) Version 2 CSE IIT, Kharagpur
Module 7 Knowledge Representation and Logic (Rule based Systems) Lesson 18 Rule based Systems - II 7.2.5 Programs in PROLOG These minimal notes on Prolog show only some of its flavor. Here are facts plays(ann,fido).
Agenda. CS301 Session 20. A logic programming trick. A simple Prolog program. Introduction to logic programming Examples Semantics
CS301 Session 20 Introduction to logic programming Examples Semantics Agenda 1 2 A logic programming trick A two-way translator in two lines of code: translate([],[]). translate([word Words],[Mot Mots])
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
Reasoning about programs. Chapter 9 of Thompson
Reasoning about programs Chapter 9 of Thompson Proof versus testing A proof will state some property of a program that holds for all inputs. Testing shows only that a property holds for a particular set
Lecture Notes on Prolog
Lecture Notes on Prolog 15-317: Constructive Logic Frank Pfenning Lecture 14 October 27, 2015 In this lecture we introduce some simple data structures such as lists, and simple algorithms on them such
PROGRAMMING IN HASKELL. Chapter 2 - First Steps
PROGRAMMING IN HASKELL Chapter 2 - First Steps 0 The Hugs System Hugs is an implementation of Haskell 98, and is the most widely used Haskell system; The interactive nature of Hugs makes it well suited
CITS3211 FUNCTIONAL PROGRAMMING
CITS3211 FUNCTIONAL PROGRAMMING 9. The λ calculus Summary: This lecture introduces the λ calculus. The λ calculus is the theoretical model underlying the semantics and implementation of functional programming
Shell CSCE 314 TAMU. Haskell Functions
1 CSCE 314: Programming Languages Dr. Dylan Shell Haskell Functions 2 Outline Defining Functions List Comprehensions Recursion 3 Conditional Expressions As in most programming languages, functions can
1. true / false By a compiler we mean a program that translates to code that will run natively on some machine.
1. true / false By a compiler we mean a program that translates to code that will run natively on some machine. 2. true / false ML can be compiled. 3. true / false FORTRAN can reasonably be considered
Haske k ll An introduction to Functional functional programming using Haskell Purely Lazy Example: QuickSort in Java Example: QuickSort in Haskell
Haskell An introduction to functional programming using Haskell Anders Møller amoeller@cs.au.dk The most popular purely functional, lazy programming language Functional programming language : a program
Chapter 16. Logic Programming Languages
Chapter 16 Logic Programming Languages Chapter 16 Topics Introduction A Brief Introduction to Predicate Calculus Predicate Calculus and Proving Theorems An Overview of Logic Programming The Origins of
Logic Programming Languages
Logic Programming Languages Introduction Logic programming languages, sometimes called declarative programming languages Express programs in a form of symbolic logic Use a logical inferencing process to
1.3. Conditional expressions To express case distinctions like
Introduction Much of the theory developed in the underlying course Logic II can be implemented in a proof assistant. In the present setting this is interesting, since we can then machine extract from a
If a program is well-typed, then a type can be inferred. For example, consider the program
CS 6110 S18 Lecture 24 Type Inference and Unification 1 Type Inference Type inference refers to the process of determining the appropriate types for expressions based on how they are used. For example,
Lecture Notes on Prolog
Lecture Notes on Prolog 15-317: Constructive Logic Frank Pfenning Lecture 14 October 15, 2009 In this lecture we introduce some simple data structures such as lists, and simple algorithms on them such
An introduction introduction to functional functional programming programming using usin Haskell
An introduction to functional programming using Haskell Anders Møller amoeller@cs.au.dkau Haskell The most popular p purely functional, lazy programming g language Functional programming language : a program
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
Prolog Programming. Chapter 5. Controlling Backtracking : 1/16/2010
Prolog Programming Chapter 5 Controlling Backtracking : 1/16/2010 1 Chapter 5 Controlling Backtracking Preventing backtracking Examples using cut Negation as failure Problems with cut and negation 2 5.1
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
Logic Languages. Hwansoo Han
Logic Languages Hwansoo Han Logic Programming Based on first-order predicate calculus Operators Conjunction, disjunction, negation, implication Universal and existential quantifiers E A x for all x...
Functional Programming and Haskell
Functional Programming and Haskell Tim Dawborn University of Sydney, Australia School of Information Technologies Tim Dawborn Functional Programming and Haskell 1/22 What are Programming Paradigms? A programming
Family Example: Some Facts. respects(barb,dan). respects(barb,katie). respects(dan,brian). respects(dan,barbara).
Family Example: Some Facts respects(barb,dan). respects(barb,katie). respects(dan,brian). respects(dan,barbara). Some Queries?- respects(barb,katie). yes?- respects(barb,x). X=dan; % you type ; and RETURN
CSC384: Intro to Artificial Intelligence Prolog Tutorials 3&4. Hojjat Ghaderi, Fall 2006, University of Toronto
CSC384: Intro to Artificial Intelligence Prolog Tutorials 3&4 1 Debugging Programs in Prolog We talked about the graphical debugger under Windows. Now, the text-based debugger: You can put a breakpoint
CSC312 Principles of Programming Languages : Functional Programming Language. Copyright 2006 The McGraw-Hill Companies, Inc.
CSC312 Principles of Programming Languages : Functional Programming Language Overview of Functional Languages They emerged in the 1960 s with Lisp Functional programming mirrors mathematical functions:
Exercise 1 ( = 22 points)
1 Exercise 1 (4 + 3 + 4 + 5 + 6 = 22 points) The following data structure represents polymorphic lists that can contain values of two types in arbitrary order: data DuoList a b = C a (DuoList a b) D b
Specifying and Implementing Theorem Provers in a Higher-Order Logic Programming Language
Specifying and Implementing Theorem Provers in a Higher-Order Logic Programming Language Amy P. Felty A dissertation in Computer and Information Science Presented to the Faculties of the University of
UNIVERSITETET I OSLO
Exam in INF3110, December 12, 2013 Page 1 UNIVERSITETET I OSLO Det matematisk-naturvitenskapelige fakultet Exam in: INF3110 Programming Languages Day of exam: December 12, 2013 Exam hours: 14:30 18:30
Exercise 1 ( = 24 points)
1 Exercise 1 (4 + 5 + 4 + 6 + 5 = 24 points) The following data structure represents polymorphic binary trees that contain values only in special Value nodes that have a single successor: data Tree a =
Haskell: Lists. CS F331 Programming Languages CSCE A331 Programming Language Concepts Lecture Slides Friday, February 24, Glenn G.
Haskell: Lists CS F331 Programming Languages CSCE A331 Programming Language Concepts Lecture Slides Friday, February 24, 2017 Glenn G. Chappell Department of Computer Science University of Alaska Fairbanks
Functional Programming in Haskell Part 2 : Abstract dataypes and infinite structures
Functional Programming in Haskell Part 2 : Abstract dataypes and infinite structures Madhavan Mukund Chennai Mathematical Institute 92 G N Chetty Rd, Chennai 600 017, India madhavan@cmi.ac.in http://www.cmi.ac.in/
Lambda Terms, Types and Tree-Arithmetic
Lambda Terms, Types and Tree-Arithmetic Paul Tarau Department of Computer Science and Engineering University of North Texas July 22, 2016 Research supported by NSF grant 1423324 Paul Tarau (University
Logic Programming and PROLOG (III)
Logic Programming and PROLOG (III) Dr. Antonio L. Bajuelos Note: The most of the information of these slides was extracted and adapted from Bratko s book, Prolog Programming for Artificial Intelligence".
Theorem Proving Principles, Techniques, Applications Recursion
NICTA Advanced Course Theorem Proving Principles, Techniques, Applications Recursion 1 CONTENT Intro & motivation, getting started with Isabelle Foundations & Principles Lambda Calculus Higher Order Logic,
n n Try tutorial on front page to get started! n spring13/ n Stack Overflow!
Announcements n Rainbow grades: HW1-6, Quiz1-5, Exam1 n Still grading: HW7, Quiz6, Exam2 Intro to Haskell n HW8 due today n HW9, Haskell, out tonight, due Nov. 16 th n Individual assignment n Start early!
Lambda Calculus and Type Inference
Lambda Calculus and Type Inference Björn Lisper Dept. of Computer Science and Engineering Mälardalen University bjorn.lisper@mdh.se http://www.idt.mdh.se/ blr/ August 17, 2007 Lambda Calculus and Type
Brief Introduction to Prolog
CSC384: Intro to Artificial Intelligence Brief Introduction to Prolog Prolog Programming for Artificial Intelligence by Ivan Bratko. Prolog is a language that is useful for doing symbolic and logic based
Introduction to ML. Mooly Sagiv. Cornell CS 3110 Data Structures and Functional Programming
Introduction to ML Mooly Sagiv Cornell CS 3110 Data Structures and Functional Programming Typed Lambda Calculus Chapter 9 Benjamin Pierce Types and Programming Languages Call-by-value Operational Semantics
Chapter 16. Logic Programming. Topics. Predicate Calculus and Proving Theorems. Resolution. Resolution: example. Unification and Instantiation
Topics Chapter 16 Logic Programming Proving Theorems Resolution Instantiation and Unification Prolog Terms Clauses Inference Process Backtracking 2 Predicate Calculus and Proving Theorems A use of propositions
SOFTWARE ENGINEERING DESIGN I
2 SOFTWARE ENGINEERING DESIGN I 3. Schemas and Theories The aim of this course is to learn how to write formal specifications of computer systems, using classical logic. The key descriptional technique
First-Order Logic (FOL)
First-Order Logic (FOL) FOL consists of the following parts: Objects/terms Quantified variables Predicates Logical connectives Implication Objects/Terms FOL is a formal system that allows us to reason
Implementação de Linguagens 2016/2017
Implementação de Linguagens Ricardo Rocha DCC-FCUP, Universidade do Porto ricroc @ dcc.fc.up.pt Ricardo Rocha DCC-FCUP 1 Logic Programming Logic programming languages, together with functional programming
Formal Systems and their Applications
Formal Systems and their Applications Dave Clarke (Dave.Clarke@cs.kuleuven.be) Acknowledgment: these slides are based in part on slides from Benjamin Pierce and Frank Piessens 1 Course Overview Introduction
PROGRAMMING IN HASKELL. Chapter 5 - List Comprehensions
PROGRAMMING IN HASKELL Chapter 5 - List Comprehensions 0 Set Comprehensions In mathematics, the comprehension notation can be used to construct new sets from old sets. {x 2 x {1...5}} The set {1,4,9,16,25}
Chapter 16. Logic Programming Languages ISBN
Chapter 16 Logic Programming Languages ISBN 0-321-49362-1 Chapter 16 Topics Introduction A Brief Introduction to Predicate Calculus Predicate Calculus and Proving Theorems An Overview of Logic Programming
Programming Languages Fall 2014
Programming Languages Fall 2014 Lecture 7: Simple Types and Simply-Typed Lambda Calculus Prof. Liang Huang huang@qc.cs.cuny.edu 1 Types stuck terms? how to fix it? 2 Plan First I For today, we ll go back
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
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
Data Types The ML Type System
7 Data Types 7.2.4 The ML Type System The following is an ML version of the tail-recursive Fibonacci function introduced Fibonacci function in ML in Section 6.6.1: EXAMPLE 7.96 1. fun fib (n) = 2. let
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
Haskell Overview II (2A) Young Won Lim 8/9/16
(2A) Copyright (c) 2016 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published
Lecture Notes on Prolog
Lecture Notes on Prolog 15-317: Constructive Logic Frank Pfenning Lecture 15 October 24, 2017 1 Introduction Prolog is the first and still standard backward-chaining logic programming language. While it
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
c constructor P, Q terms used as propositions G, H hypotheses scope identifier for a notation scope M, module identifiers t, u arbitrary terms
Coq quick reference Meta variables Usage Meta variables Usage c constructor P, Q terms used as propositions db identifier for a hint database s string G, H hypotheses scope identifier for a notation scope
Coq quick reference. Category Example Description. Inductive type with instances defined by constructors, including y of type Y. Inductive X : Univ :=
Coq quick reference Category Example Description Meta variables Usage Meta variables Usage c constructor P, Q terms used as propositions db identifier for a hint database s string G, H hypotheses scope
Operational Semantics
15-819K: Logic Programming Lecture 4 Operational Semantics Frank Pfenning September 7, 2006 In this lecture we begin in the quest to formally capture the operational semantics in order to prove properties
Programming Systems in Artificial Intelligence Introduction
Click to add Text Programming Systems in Artificial Intelligence Introduction Siegfried Nijssen 23/02/16 Discover thediscover world at the Leiden world University at Leiden University Programming Paradigms
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.
Final Exam : Constructive Logic. December 9, Prob 1 Prob 2 Prob 3 Prob 4 Prob 5 Prob 6 Prob 7 Prob 8 Total
Final Exam 15-317: Constructive Logic December 9, 2008 Name: Andrew ID: Instructions This exam is open-book. You have 3 hours to complete the exam. There are 8 problems. Prob 1 Prob 2 Prob 3 Prob 4 Prob
Types and Type Inference
CS 242 2012 Types and Type Inference Notes modified from John Mitchell and Kathleen Fisher Reading: Concepts in Programming Languages, Revised Chapter 6 - handout on Web!! Outline General discussion of
LP attracted two kinds of enthousiasts engineers/programmers \Never had I experienced such ease in getting a complex program coded and running" D.H.D.
Logic Programming Revisited Logic Programs as Inductive Denitions An engineers' view Maurice Bruynooghe Katholieke Universiteit Leuven, Belgium Partly based on work of Marc Denecker In the beginning (1974),
PROgramming in LOGic PROLOG Recursion, Lists & Predicates
PROgramming in LOGic PROLOG Recursion, Lists & Predicates CSC9Y4 1 Recursion Recursion in Prolog means placing in the body of a rule a call to the predicate which occurs in the head of the rule. Here is
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
CSCE 314 TAMU Fall CSCE 314: Programming Languages Dr. Flemming Andersen. Haskell Basics
1 CSCE 314: Programming Languages Dr. Flemming Andersen Haskell Basics 2 Contents 1. Jump into Haskell: Using ghc and ghci (more detail) 2. Historical Background of Haskell 3. Lazy, Pure, and Functional
CSCE 314 Programming Languages. Functional Parsers
CSCE 314 Programming Languages Functional Parsers Dr. Hyunyoung Lee 1 What is a Parser? A parser is a program that takes a text (set of tokens) and determines its syntactic structure. String or [Token]