DOCSLIB.ORG

The Current Topic: Prolog Announcements Using Not Instead

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
The Current Topic: Prolog Announcements Using Not Instead The current topic: Prolog Announcements • Term Test 2 has been marked. ! Introduction – Handed back at the end of class today. ! Object-oriented programming: Python – The deadline for submitting a re-mark request is the end of class, Friday November 28th. Make sure you understand the posted solutions before ! Functional programming: Scheme submitting a re-mark request. ! Python GUI programming (Tkinter) – Average: 68.4% ! Types and values • Logic programming: Prolog ! Introduction ! Rules, unification, resolution, backtracking, lists. ! More lists, math, structures. ! More structures, trees, cut. – Next up: Negation. • Syntax and semantics • Exceptions Fall 2008 Prolog: Negation 1 Fall 2008 Prolog: Negation 2 Using not instead of cut to avoid wrong answers Using not for inequality • Example: • Prolog has a not operator, but its behaviour is more subtle than in other crispy(snap). languages. crispy(crackle). crispy(pop). • Example: Replacing a cut with not: breakfast(A,B,C) :- crispy(A), crispy(B), crispy(C). – With cut: ?- breakfast(A,B,C). A :- B, !, C. A = snap A :- D. B = snap – With not: C = snap ; A :- B, C. A :- not(B), D. A = snap B = snap C = crackle ; • Observe that not can be more cumbersome than cut. ... – repetitive if-then-else • But we really want A, B, and C to be different from each other. Fall 2008 Prolog: Negation 3 Fall 2008 Prolog: Negation 4 Using not for inequality Negation in Prolog crispy(snap). • not(B) can also be written as \+ B. crispy(crackle). – And not(X=Y) can also be written as X \= Y. crispy(pop). breakfast(A,B,C) :- crispy(A), crispy(B), crispy(C), not(A=B), • The goal \+ X succeeds iff X fails. not(A=C), not(B=C). • Examples: ?- breakfast(A,B,C). ?- \+ member(b, [a,b,c]). A = snap No B = crackle ?- \+ member(x, [a,b,c]). C = pop ; Yes ?- \+ member(X, [a,b,c]). A = snap No B = pop C = crackle ; ... Fall 2008 Prolog: Negation 5 Fall 2008 Prolog: Negation 6 Negation in Prolog Negation as failure ?- \+ member(X, [a,b,c]). • Prolog assumes that if it can't prove an assertion, then the assertion is No false. – And Prolog assumes that if it can prove an assertion, then the assertion is true. • It might look like this query is asking "Does there exist an X for which member(X, [a,b,c]) does not succeed?". • This is the "closed world assumption": in the universe of facts Prolog – We know there are lots of values of X for which member(X, [a,b,c]) does not knows about, failure to prove is proof of failure. succeed. – But if we know something Prolog doesn't, this can lead to surprises: things that – But that's not what negation means in Prolog. Prolog thinks are false when we know they're true, and the opposite. – There exists X for which member(X, [a,b,c]) succeeds. – Example: – So then \+ member(X, [a,b,c]) fails. university(uoft). ?- university(york). No ?- \+ university(york). Yes Fall 2008 Prolog: Negation 7 Fall 2008 Prolog: Negation 8 Be careful with negation Tracing negation sad(X) :- \+ happy(X). ?- sad(michael). • Let's look at how Prolog answers sad(Someone).: happy(X) :- beautiful(X), rich(X). No rich(bill). ?- sad(jim). ?- sad(Someone). beautiful(michael). Yes Call: (7) sad(_G283) ? creep rich(michael). ?- sad(Someone). beautiful(cinderella). No Call: (8) happy(_G283) ? creep Call: (9) beautiful(_G283) ? creep ?- sad(bill). • Isn't anyone sad? Exit: (9) beautiful(michael) ? creep Call: (9) rich(michael) ? creep Yes • No, that just means that it's Exit: (9) rich(michael) ? creep ?- sad(cinderella). not true we can't find anyone Exit: (8) happy(michael) ? creep Yes happy. Fail: (7) sad(_G283) ? creep – In other words, there exists someone who is happy. No Fall 2008 Prolog: Negation 9 Fall 2008 Prolog: Negation 10 Set overlap What does that mean? • Write a predicate overlap(S1, S2) that succeeds if lists S1 and S2 have a common element. Then write a predicate disjoint(S1, S2) ?- disjoint([a,b,d], S). that succeeds if S1 and S2 have no common element. No overlap(S1, S2) :- member(X, S1), member(X, S2). • The query should mean "can you find a list S that is disjoint from the list disjoint(S1, S2) :- \+ overlap(S1, S2). [a,b,d] (and if so what is it)?". • Obviously there are many such sets, so why "No"? ?- overlap([a,b,c], [c,d,e]). • Answer: because Prolog succeeded in finding a set that did overlap with Yes S, so it announced failure of the original query. ?- disjoint([a,b,c], [c,d,e]). No ?- overlap([a,b,d], S). ?- overlap([a,b,c], [d,e,f]). S = [a|_G226] ; No S = [_G225, a|_G229] ; ?- disjoint([a,b,c], [d,e,f]). S = [_G225, _G228, a|_G232] ; Yes ... ?- disjoint([a,b,d], S). No Fall 2008 Prolog: Negation 11 Fall 2008 Prolog: Negation 12 Safe use of negation Double-negation doesn't "cancel out" • The goal not(G) is safe if either: • In other languages, not(not(<expression>)) is equivalent to – G is fully instantiated when not(G) is processed, or <expression>. – G has uninstantiated variables, but they don't appear anywhere else in the clause. – But not in Prolog. • Safe example: ?- member(X,[a,b,c]). childlessMan(X) :- male(X), \+ parent(X,Y). X = a ; – X is instantiated in male(X), and Y isn't used elsewhere. X = b ; X = c ; No • Unsafe example: childlessMan(X) :- \+ parent(X,Y), male(X). ?- not(not(member(X,[a,b,c]))). – X is not instantiated before the negation, and is used elsewhere. X = _G166 ; No • If necessary, add a precondition to warn the programmer. – recall that +Var means that Var must be instantiated. % disjoint(+S1, +S2) succeeds if... disjoint(S1, S2) :- \+ overlap(S1, S2). – When the precondition is satisfied, this negation is safe. Fall 2008 Prolog: Negation 13 Fall 2008 Prolog: Negation 14 Double-negation doesn't "cancel out" fail • The fail predicate fails immediately. Example: ?- not(not(member(X,[a,b,c]))). X = _G166 ; p(X) :- fail. No ?- p(csc326). • Why is X uninstantiated in this example? No – Since member(X, [a,b,c]) succeeds (by instantiating X to, say, a), not(member(X, [a,b,c])) fails. • We can use fail to state that something is false. – When a goal fails, the variables it instantiated get uninstantiated. So X gets uninstantiated. – But since not(member(X, [a,b,c])) fails, not(not(member(X, [a,b,c]))) succeeds. Fall 2008 Prolog: Negation 15 Fall 2008 Prolog: Negation 16 fail fail • Example: We want to represent "Colbert does not like bears (regardless • We need to add a cut to prevent other rules from being tried after the of whatever else he likes)." first rule reaches fail. – One solution: Add "not(bear(X))" to every rule describing what Colbert likes. – Second attempt: For example: bear(yogi). likes(colbert, X) :- animal(X), not(bear(X)). cat(tom). likes(colbert, X) :- toy(X), not(bear(X)). animal(yogi). likes(colbert, X) :- livesInArctic(X), not(bear(X)). animal(tom). ... likes(colbert, X) :- bear(X), !, fail. – Let's try to use fail instead. likes(colbert, X) :- animal(X). – First attempt: bear(yogi). ?- likes(colbert, yogi). animal(yogi). No likes(colbert, X) :- bear(X), fail. ?- likes(colbert, tom). likes(colbert, X) :- animal(X). Yes ?- likes(colbert, X). ?- likes(colbert, yogi). No Yes – Downside: This solution only works when X is instantiated. Fall 2008 Prolog: Negation 17 Fall 2008 Prolog: Negation 18 fail Defining "not" using cut and fail • Another example: Define a predicate different(X, Y) that succeeds • We can define the not predicate as follows: if X and Y don't unify. not(X) :- X, !, fail. different(X, Y) :- X=Y, !, fail. not(_). different(_, _). • (To test this out, use a name other than "not", since Prolog won't let ?- different(a, b). you redefine the built-in "not"). Yes ?- different(a, a). No • Notice that the above definition is equivalent to: different(X, Y) :- not(X=Y). Fall 2008 Prolog: Negation 19 Fall 2008 Prolog: Negation 20 fail Inefficiency in bstmem • Recall the original version of bstmem(Tree, X): [trace] ?- bstmem(node(5, node(3,empty,empty), emtpy), 1). bstmem(node(X, _, _), X). Call: (8) bstmem(node(5, node(3, empty, empty), emtpy), 1) ? bstmem(node(K, L, _), X) :- X < K, bstmem(L, X). creep ^ Call: (9) 1<5 ? creep bstmem(node(K, _, R), X) :- X > K, bstmem(R, X). ^ Exit: (9) 1<5 ? creep Call: (9) bstmem(node(3, empty, empty), 1) ? creep • Recall that this version was inefficient. ^ Call: (10) 1<3 ? creep ^ Exit: (10) 1<3 ? creep Call: (10) bstmem(empty, 1) ? creep Fail: (10) bstmem(empty, 1) ? creep Redo: (9) bstmem(node(3, empty, empty), 1) ? creep ^ Call: (10) 1>3 ? creep ^ Fail: (10) 1>3 ? creep Redo: (8) bstmem(node(5, node(3, empty, empty), emtpy), 1) ? creep ^ Call: (9) 1>5 ? creep ^ Fail: (9) 1>5 ? creep No Fall 2008 Prolog: Negation 21 Fall 2008 Prolog: Negation 22 fail Tracing the new bstmem • We solved the inefficiency illustrated on the previous slide as follows: [trace] ?- bstmem(node(5, node(3,empty,empty), emtpy), 1). Call: (8) bstmem(node(5, node(3, empty, empty), emtpy), 1) ? creep bstmem(node(X, _, _), X). ^ Call: (9) 1<5 ? creep bstmem(node(K, L, _), X) :- X < K, !, bstmem(L, X). ^ Exit: (9) 1<5 ? creep bstmem(node(K, _, R), X) :- X > K, bstmem(R, X). Call: (9) bstmem(node(3, empty, empty), 1) ? creep ^ Call: (10) 1<3 ? creep ^ Exit: (10) 1<3 ? creep • What if we try to instead solve this inefficiency by using fail: Call: (10) bstmem(empty, 1) ? creep Call: (11) fail ? creep bstmem(empty,_) :- !, fail.
Load more

Recommended publications
  • B-Prolog User's Manual
    B-Prolog User's Manual (Version 8.1) Prolog, Agent, and Constraint Programming Neng-Fa Zhou Afany Software & CUNY & Kyutech Copyright c Afany Software, 1994-2014. Last updated February 23, 2014 Preface Welcome to B-Prolog, a versatile and efficient constraint logic programming (CLP) system. B-Prolog is being brought to you by Afany Software. The birth of CLP is a milestone in the history of programming languages. CLP combines two declarative programming paradigms: logic programming and constraint solving. The declarative nature has proven appealing in numerous ap- plications, including computer-aided design and verification, databases, software engineering, optimization, configuration, graphical user interfaces, and language processing. It greatly enhances the productivity of software development and soft- ware maintainability. In addition, because of the availability of efficient constraint- solving, memory management, and compilation techniques, CLP programs can be more efficient than their counterparts that are written in procedural languages. B-Prolog is a Prolog system with extensions for programming concurrency, constraints, and interactive graphics. The system is based on a significantly refined WAM [1], called TOAM Jr. [19] (a successor of TOAM [16]), which facilitates software emulation. In addition to a TOAM emulator with a garbage collector that is written in C, the system consists of a compiler and an interpreter that are written in Prolog, and a library of built-in predicates that are written in C and in Prolog. B-Prolog does not only accept standard-form Prolog programs, but also accepts matching clauses, in which the determinacy and input/output unifications are explicitly denoted. Matching clauses are compiled into more compact and faster code than standard-form clauses.
    [Show full text]
  • Cobol Vs Standards and Conventions
    Number: 11.10 COBOL VS STANDARDS AND CONVENTIONS July 2005 Number: 11.10 Effective: 07/01/05 TABLE OF CONTENTS 1 INTRODUCTION .................................................................................................................................................. 1 1.1 PURPOSE .................................................................................................................................................. 1 1.2 SCOPE ...................................................................................................................................................... 1 1.3 APPLICABILITY ........................................................................................................................................... 2 1.4 MAINFRAME COMPUTER PROCESSING ....................................................................................................... 2 1.5 MAINFRAME PRODUCTION JOB MANAGEMENT ............................................................................................ 2 1.6 COMMENTS AND SUGGESTIONS ................................................................................................................. 3 2 COBOL DESIGN STANDARDS .......................................................................................................................... 3 2.1 IDENTIFICATION DIVISION .................................................................................................................. 4 2.1.1 PROGRAM-ID ..........................................................................................................................
    [Show full text]
  • A Quick Reference to C Programming Language
    A Quick Reference to C Programming Language Structure of a C Program #include(stdio.h) /* include IO library */ #include... /* include other files */ #define.. /* define constants */ /* Declare global variables*/) (variable type)(variable list); /* Define program functions */ (type returned)(function name)(parameter list) (declaration of parameter types) { (declaration of local variables); (body of function code); } /* Define main function*/ main ((optional argc and argv arguments)) (optional declaration parameters) { (declaration of local variables); (body of main function code); } Comments Format: /*(body of comment) */ Example: /*This is a comment in C*/ Constant Declarations Format: #define(constant name)(constant value) Example: #define MAXIMUM 1000 Type Definitions Format: typedef(datatype)(symbolic name); Example: typedef int KILOGRAMS; Variables Declarations: Format: (variable type)(name 1)(name 2),...; Example: int firstnum, secondnum; char alpha; int firstarray[10]; int doublearray[2][5]; char firststring[1O]; Initializing: Format: (variable type)(name)=(value); Example: int firstnum=5; Assignments: Format: (name)=(value); Example: firstnum=5; Alpha='a'; Unions Declarations: Format: union(tag) {(type)(member name); (type)(member name); ... }(variable name); Example: union demotagname {int a; float b; }demovarname; Assignment: Format: (tag).(member name)=(value); demovarname.a=1; demovarname.b=4.6; Structures Declarations: Format: struct(tag) {(type)(variable); (type)(variable); ... }(variable list); Example: struct student {int
    [Show full text]
  • A Tutorial Introduction to the Language B
    A TUTORIAL INTRODUCTION TO THE LANGUAGE B B. W. Kernighan Bell Laboratories Murray Hill, New Jersey 1. Introduction B is a new computer language designed and implemented at Murray Hill. It runs and is actively supported and documented on the H6070 TSS system at Murray Hill. B is particularly suited for non-numeric computations, typified by system programming. These usually involve many complex logical decisions, computations on integers and fields of words, especially charac- ters and bit strings, and no floating point. B programs for such operations are substantially easier to write and understand than GMAP programs. The generated code is quite good. Implementation of simple TSS subsystems is an especially good use for B. B is reminiscent of BCPL [2] , for those who can remember. The original design and implementation are the work of K. L. Thompson and D. M. Ritchie; their original 6070 version has been substantially improved by S. C. Johnson, who also wrote the runtime library. This memo is a tutorial to make learning B as painless as possible. Most of the features of the language are mentioned in passing, but only the most important are stressed. Users who would like the full story should consult A User’s Reference to B on MH-TSS, by S. C. Johnson [1], which should be read for details any- way. We will assume that the user is familiar with the mysteries of TSS, such as creating files, text editing, and the like, and has programmed in some language before. Throughout, the symbolism (->n) implies that a topic will be expanded upon in section n of this manual.
    [Show full text]
  • Quick Tips and Tricks: Perl Regular Expressions in SAS® Pratap S
    Paper 4005-2019 Quick Tips and Tricks: Perl Regular Expressions in SAS® Pratap S. Kunwar, Jinson Erinjeri, Emmes Corporation. ABSTRACT Programming with text strings or patterns in SAS® can be complicated without the knowledge of Perl regular expressions. Just knowing the basics of regular expressions (PRX functions) will sharpen anyone's programming skills. Having attended a few SAS conferences lately, we have noticed that there are few presentations on this topic and many programmers tend to avoid learning and applying the regular expressions. Also, many of them are not aware of the capabilities of these functions in SAS. In this presentation, we present quick tips on these expressions with various applications which will enable anyone learn this topic with ease. INTRODUCTION SAS has numerous character (string) functions which are very useful in manipulating character fields. Every SAS programmer is generally familiar with basic character functions such as SUBSTR, SCAN, STRIP, INDEX, UPCASE, LOWCASE, CAT, ANY, NOT, COMPARE, COMPBL, COMPRESS, FIND, TRANSLATE, TRANWRD etc. Though these common functions are very handy for simple string manipulations, they are not built for complex pattern matching and search-and-replace operations. Regular expressions (RegEx) are both flexible and powerful and are widely used in popular programming languages such as Perl, Python, JavaScript, PHP, .NET and many more for pattern matching and translating character strings. Regular expressions skills can be easily ported to other languages like SQL., However, unlike SQL, RegEx itself is not a programming language, but simply defines a search pattern that describes text. Learning regular expressions starts with understanding of character classes and metacharacters.
    [Show full text]
  • The Programming Language Concurrent Pascal
    IEEE TRANSACTIONS ON SOFTWARE ENGINEERING, VOL. SE-I, No.2, JUNE 1975 199 The Programming Language Concurrent Pascal PER BRINCH HANSEN Abstract-The paper describes a new programming language Disk buffer for structured programming of computer operating systems. It e.lt­ tends the sequential programming language Pascal with concurx:~t programming tools called processes and monitors. Section I eltplains these concepts informally by means of pictures illustrating a hier­ archical design of a simple spooling system. Section II uses the same enmple to introduce the language notation. The main contribu~on of Concurrent Pascal is to extend the monitor concept with an .ex­ Producer process Consumer process plicit hierarchy Of access' rights to shared data structures that can Fig. 1. Process communication. be stated in the program text and checked by a compiler. Index Terms-Abstract data types, access rights, classes, con­ current processes, concurrent programming languages, hierarchical operating systems, monitors, scheduling, structured multiprogram­ ming. Access rights Private data Sequential 1. THE PURPOSE OF CONCURRENT PASCAL program A. Background Fig. 2. Process. INCE 1972 I have been working on a new programming .. language for structured programming of computer S The next picture shows a process component in more operating systems. This language is called Concurrent detail (Fig. 2). Pascal. It extends the sequential programming language A process consists of a private data structure and a Pascal with concurrent programming tools called processes sequential program that can operate on the data. One and monitors [1J-[3]' process cannot operate on the private data of another This is an informal description of Concurrent Pascal.
    [Show full text]
  • Introduction to Shell Programming Using Bash Part I
    Introduction to shell programming using bash Part I Deniz Savas and Michael Griffiths 2005-2011 Corporate Information and Computing Services The University of Sheffield Email [email protected] [email protected] Presentation Outline • Introduction • Why use shell programs • Basics of shell programming • Using variables and parameters • User Input during shell script execution • Arithmetical operations on shell variables • Aliases • Debugging shell scripts • References Introduction • What is ‘shell’ ? • Why write shell programs? • Types of shell What is ‘shell’ ? • Provides an Interface to the UNIX Operating System • It is a command interpreter – Built on top of the kernel – Enables users to run services provided by the UNIX OS • In its simplest form a series of commands in a file is a shell program that saves having to retype commands to perform common tasks. • Shell provides a secure interface between the user and the ‘kernel’ of the operating system. Why write shell programs? • Run tasks customised for different systems. Variety of environment variables such as the operating system version and type can be detected within a script and necessary action taken to enable correct operation of a program. • Create the primary user interface for a variety of programming tasks. For example- to start up a package with a selection of options. • Write programs for controlling the routinely performed jobs run on a system. For example- to take backups when the system is idle. • Write job scripts for submission to a job-scheduler such as the sun- grid-engine. For example- to run your own programs in batch mode. Types of Unix shells • sh Bourne Shell (Original Shell) (Steven Bourne of AT&T) • csh C-Shell (C-like Syntax)(Bill Joy of Univ.
    [Show full text]
  • An Analysis of the D Programming Language Sumanth Yenduri University of Mississippi- Long Beach
    View metadata, citation and similar papers at core.ac.uk brought to you by CORE provided by CSUSB ScholarWorks Journal of International Technology and Information Management Volume 16 | Issue 3 Article 7 2007 An Analysis of the D Programming Language Sumanth Yenduri University of Mississippi- Long Beach Louise Perkins University of Southern Mississippi- Long Beach Md. Sarder University of Southern Mississippi- Long Beach Follow this and additional works at: http://scholarworks.lib.csusb.edu/jitim Part of the Business Intelligence Commons, E-Commerce Commons, Management Information Systems Commons, Management Sciences and Quantitative Methods Commons, Operational Research Commons, and the Technology and Innovation Commons Recommended Citation Yenduri, Sumanth; Perkins, Louise; and Sarder, Md. (2007) "An Analysis of the D Programming Language," Journal of International Technology and Information Management: Vol. 16: Iss. 3, Article 7. Available at: http://scholarworks.lib.csusb.edu/jitim/vol16/iss3/7 This Article is brought to you for free and open access by CSUSB ScholarWorks. It has been accepted for inclusion in Journal of International Technology and Information Management by an authorized administrator of CSUSB ScholarWorks. For more information, please contact [email protected]. Analysis of Programming Language D Journal of International Technology and Information Management An Analysis of the D Programming Language Sumanth Yenduri Louise Perkins Md. Sarder University of Southern Mississippi - Long Beach ABSTRACT The C language and its derivatives have been some of the dominant higher-level languages used, and the maturity has stemmed several newer languages that, while still relatively young, possess the strength of decades of trials and experimentation with programming concepts.
    [Show full text]
  • C Programming Tutorial
    C Programming Tutorial C PROGRAMMING TUTORIAL Simply Easy Learning by tutorialspoint.com tutorialspoint.com i COPYRIGHT & DISCLAIMER NOTICE All the content and graphics on this tutorial are the property of tutorialspoint.com. Any content from tutorialspoint.com or this tutorial may not be redistributed or reproduced in any way, shape, or form without the written permission of tutorialspoint.com. Failure to do so is a violation of copyright laws. This tutorial may contain inaccuracies or errors and tutorialspoint provides no guarantee regarding the accuracy of the site or its contents including this tutorial. If you discover that the tutorialspoint.com site or this tutorial content contains some errors, please contact us at [email protected] ii Table of Contents C Language Overview .............................................................. 1 Facts about C ............................................................................................... 1 Why to use C ? ............................................................................................. 2 C Programs .................................................................................................. 2 C Environment Setup ............................................................... 3 Text Editor ................................................................................................... 3 The C Compiler ............................................................................................ 3 Installation on Unix/Linux ............................................................................
    [Show full text]
  • Shell Script: the Shell Is the Part of the UNIX That Is Most Visible to the User. It Receives and Interprets the Commands Entered by the User
    Shell Script: The shell is the part of the UNIX that is most visible to the user. It receives and interprets the commands entered by the user. In many respects, this makes it the most important component of the UNIX structure. To do anything in the system, we should give the shell a command. If the command requires a utility, the shell requests that the kernel execute the utility. If the command requires an application program, the shell requests that it be run. The standard shells are of different types as There are two major parts to a shell. The first is the interpreter. The interpreter reads your commands and works with the kernel to execute them. The second part of the shell is a programming capability that allows you to write a shell (command) script. A shell script is a file that contains shell commands that perform a useful function. It is also known as shell program. Three additional shells are used in UNIX today. The Bourne shell, developed by Steve Bourne at the AT&T labs, is the oldest. Because it is the oldest and most primitive, it is not used on many systems today. An enhanced version of Bourne shell, called Bash (Bourne again shell), is used in Linux. The C shell, developed in Berkeley by Bill Joy, received its name from the fact that its commands were supposed to look like C statements. A compatible version of C shell, called tcsh is used in Linux. The Korn shell, developed by David Korn also of the AT&T labs, is the newest and most powerful.
    [Show full text]
  • Programming Languages and Translators
    Programming Languages and Translators Ronghui Gu Spring 2019 Columbia University 1 Instructor Prof. Ronghui Gu 515 Computer Science Building [email protected] Oce hours: Thursdays 1:30 - 2:30 PM / by appointment Prof. Stephen A. Edwards and Prof. Baishakhi Rey also teach 4115. ∗These slides are borrowed from Prof. Edwards. 2 What is a Programming Language? A programming language is a notation that a person and a computer can both understand. • It allows you to express what is the task to compute • It allows a computer to execute the computation task Every programming language has a syntax and semantics. • Syntax: how characters combine to form a program • Semantics: what the program means 3 Components of a language: Syntax How characters combine to form a program. Calculate the n-th Fibonacci number. is syntactically correct English, but isn’t a Java program. c l a s s Foo { p u b l i c int j; p u b l i c int foo(int k){ return j+k;} } is syntactically correct Java, but isn’t C. 4 Specifying Syntax Usually done with a context-free grammar. Typical syntax for algebraic expressions: expr ! expr + expr j expr − expr j expr ∗ expr j expr = expr j ( expr ) j digits 5 Components of a language: Semantics What a well-formed program “means.” The semantics of C says this computes the nth Fibonacci number. i n t fib(int n) { i n t a=0,b=1; i n t i; f o r (i=1 ; i<n ; i++){ i n t c=a+b; a = b ; b = c ; } return b; } 6 Semantics Something may be syntactically correct but semantically nonsensical The rock jumped through the hairy planet.
    [Show full text]
  • An Introduction to Prolog
    Appendix A An Introduction to Prolog A.1 A Short Background Prolog was designed in the 1970s by Alain Colmerauer and a team of researchers with the idea – new at that time – that it was possible to use logic to represent knowledge and to write programs. More precisely, Prolog uses a subset of predicate logic and draws its structure from theoretical works of earlier logicians such as Herbrand (1930) and Robinson (1965) on the automation of theorem proving. Prolog was originally intended for the writing of natural language processing applications. Because of its conciseness and simplicity, it became popular well beyond this domain and now has adepts in areas such as: • Formal logic and associated forms of programming • Reasoning modeling • Database programming • Planning, and so on. This chapter is a short review of Prolog. In-depth tutorials include: in English, Bratko (2012), Clocksin and Mellish (2003), Covington et al. (1997), and Sterling and Shapiro (1994); in French, Giannesini et al. (1985); and in German, Baumann (1991). Boizumault (1988, 1993) contain a didactical implementation of Prolog in Lisp. Prolog foundations rest on first-order logic. Apt (1997), Burke and Foxley (1996), Delahaye (1986), and Lloyd (1987) examine theoretical links between this part of logic and Prolog. Colmerauer started his work at the University of Montréal, and a first version of the language was implemented at the University of Marseilles in 1972. Colmerauer and Roussel (1996) tell the story of the birth of Prolog, including their try-and-fail experimentation to select tractable algorithms from the mass of results provided by research in logic.
    [Show full text]