Introduction to Prolog

Transcription

1 Introduction to Prolog David Woods Week 3 - HT Declarative Logic The Prolog programming language is, at its theoretical core, a declarative language. This is unlike more commonly used languages such as Java, C++, Python, etc., which are imperative programming languages. A declarative language is suited for symbolic computation and information processing. We will use facts and rules, and create relations between them in order to produce the results we want. Rather than giving the computer instructions on what we want it to do, we use logic to reason about what we already know. Logic is a non-empirical science of reasoning, meaning it isn t observational or experimental. What is logically true once should always be true when following the same logic. In order to use logic, we must distinguish between correct and incorrect reasoning and make inferences. To infer is to draw conclusions from premises data / information / facts. Examples You see smoke coming from an open doorway, what do you infer? the room is on fire? someone is cooking and forgot to turn on the fan? someone is smoking a cigar? You see a crowd of people standing in a circle...?? Reasoning Process When we reason, we make arguments, built up of a collection of statements. Statements are declarative sentences, which are capable of being either true or false. Of these, one is the conclusion, and the remainder are known as the premises. We infer from the premises to the conclusion: An example of an argument may look as follows: Deductive vs Inductive Premises (P 1 P 2...) Conclusion (C) there is smoke (Premise) therefore, there is fire (Conclusion) Inductive logic the process of drawing likely or plausible conclusions from the premises. It is not an infallible logic, meaning it can lead to conclusions which seem logical, but are in fact false. Deductive logic the process whereby the truth of the premises means that, necessarily, the conclusion must also certainly be true. 1

2 Compare being a CSL student being a CS student being a CS student being a CSL student Statements and Propositions Statements also known as sentences, consist of strings of language, and are dependent on the particular language used. They may be spoken as sounds or written as symbols. We will focus on the latter for now. Propositions asserted by statements, and are independent of the language used. These will give meaning to a statement in the same way that a noun is given meaning by the object it denotes. Content vs Form Even though the premises may support the conclusion, they may not themselves make sense. Alternatively, the premises may each be valid, but do not support the conclusion. In these scenarios, we speak of content and form: Good Content, Bad Form 1. all guitars are musical instruments 2. all pianos are musical instruments 3. therefore, all guitars are pianos Good Form, Bad Content 1. all guitars are pianos 2. all pianos are musical instruments 3. therefore, all guitars are musical instruments Objects in Prolog Prolog code is made up of various kinds of data objects, generally called terms, which are denoted by strings of characters, including upper- and lower-case letters, digits, and some special characters. We will work with every kind of data object over the course of the syllabus. Data objects are split up as follows: data objects simple objects structures constants variables atoms numbers Creating Prolog Terms We have a number of types of data, and each is constructed in its own way. Atoms are the simplest kind of term, and can be formed from a string of letters, digits and the underscore ( ), but must begin with a lowercase letter. Alternatively, a string of any characters wrapped in single-quotes may also describe an atom. The following are valid atoms: anna 2

3 x25 x 25 miss Smith Tom Miss Smith Numbers can be constructed from integers or real numbers: Variables are an important way of representing unknown information in Prolog. They allow us to specify that information should go in a certain location, even if we don t know what that information is. If we write the correct code, Prolog will tell us. Variables are constructed in the same way as atoms, except that they are not permitted to be wrapped in single-quotes, and they must always begin with either an upper-case letter or an underscore: Anna X25 X 25 x25 The underscore by itself is a special variable in Prolog, called the anonymous variable. We will come across it again later. Structures, more commonly known as predicates are complex terms. They consist of multiple parts, similar to a function in an imperative programming language like Java. We need a name (or functor), and arguments. The number of arguments a predicate takes is known as its arity. For example, you might have a date predicate of arity 3 (usually written as date/3), which may contain some combination of atoms, numbers, or variables as arguments: date(january, 31, 2017) date(month, Date, Year) date(january, Date, 2017) Clauses We interact with Prolog via the construction of clauses, of which there are three kinds: Fact A clause with a head but no body. Unconditionally true. Rule A clause with a head and a body. Conditionally true. Query A clause with a body but no head. Truth value to be deduced. 3

4 Examples In an example family, where Charles and Mary have one son, named Peter, who has two children, Lucy and Tom, we can construct the following facts in our Prolog knowledge base: mother(mary, peter). father(charles, peter). father(peter, lucy). father(peter, tom). These facts allow us to ask Prolog queries, which is the main way we will interact with the language as a user, rather than as a programmer. We can query the knowledge base by using a query which contains one of the predicate facts we already have in our knowledge base. Write the above four lines in a file, and save it as kb.pl this is the same file extension as used by the Perl programming language, so make sure you know what kind of code you re writing! Notice that each of the four lines of code above ends with a dot. This is important, as it signals the end of a clause to Prolog. We can load our file in two main ways: either by running prolog in the same directory as the file, then typing in [kb]., including the file name in square brackets and a dot, but not including the file extension, or by simply running prolog with the filename as an argument, e.g. prolog kb.pl. If you can see the prompt?-, then you ve successfully got Prolog running in interactive mode, and we can begin entering queries. We can now use Prolog to evaluate our file. We ll begin by asking very simple questions. At the prompt, enter the query father(charles, peter). you should get the correct response true, as this fact is in the knowledge base. If you enter the query mother(charles, peter)., you ll correctly get back false, as this fact is not in the file we wrote. What will happen if you enter father(charles, john).? The next thing we can try is replacing the atoms with variables in our queries. If we ask prolog father(x, peter)., the response will be X = charles, because this is the matching fact Prolog found in our database where it could instantiate the variable X. If we ask Prolog a question with more than one answer, we can use the semi-colon key to iterate through all the possible answers, e.g. father(peter, X). has two possible answers, so we ll see Prolog give us one of them, then we can hit ; to see the next one. Now let s add some rules to our database. You can exit the Prolog interpreter by entering the query halt. Be aware that any time you make changes to your prolog knowledge base file, you must reload it in order to see the effects of your changes. Add the following lines of code to the bottom of your file: grandfather(x, Y) :- father(x, Z), father(z, Y). grandfather(x, Y) :- father(x, Z), mother(z, Y). Now we see that the code has become a little more complex. We have added two rules to our code which allow us to define the grandfather relationship between two individuals. These two rules are exactly the same as our logical arguments from earlier, though the syntax is reversed: we read the symbol :- as if, and so the rules have the form of Conclusion if Premise1 and Premise2 i.e. The conclusion is true if all of the premises are true. By using variables, we are giving Prolog freedom to choose any combinations of X, Y, and Z that it wants, so long as there are no contradictions. We can read the code above as X is the grandfather of Y, if X is the father of some other individual Z, and Z is the father (in the first case) or mother (in the second case) of Y. It may seem convoluted to write this as two rules, rather than one rule with an or case in the middle, but it is conventional to write rules more clearly like this. Now if we run this file through Prolog again, we can ask it new queries involving the rules we just wrote. Try the following three queries, and see if the results are what you d expect:?- grandfather(charles, lucy).?- grandfather(a, tom).?- grandfather(a, B). Note that we can also load or reload a Prolog program with consult( kb.pl )., where kb.pl is the name of the file. You can also specify the path to the file here, if it is in a different directory. 4

5 Lab Exercise Try the examples given in this file. Make sure you understand the output you get. Try some of your own queries. Try editing the file by changing the names, or adding new family members. Add facts to the knowledge base, so that querying the grandfather relationship returns at least four results. Define at least one of the following predicates (note that several solutions are possible): 1. grandchild 2. sibling 3. cousin In addition to your predicate, add a description which clearly explains in English what you have done. For example, The grandfather relationship is an arity 2 rule predicate, which has two components, X and Y. X is the grandfather of Y if X is the father of some other individual Z, and Z is the father (in the first case) or mother (in the second case) of Y. You should complete your work in a file called week2ht.pl and send it to me by (dwoods@scss.tcd.ie) by 23:59 on Monday the 6th of February,