Artificial Intelligence and Lisp Lecture 3 LiU Course TDDC65 Autumn Semester,

Today's topics Evaluation of terms, in two modes: - Computational evaluation - Representational evaluation Evaluation of conditions/propositions Operations on actions: - Evaluation - Execution

Today's topics Evaluation of terms, in two modes: - Computational evaluation - Representational evaluation Examples: (+.a 5) (father-of sven) (age (father-of sven)) Evaluation of conditions/propositions Example: [less-than (age (father-of sven)) 50] Operations on actions: - Evaluation - Execution Examples: [call-by-phone sven (father-of sven)] [call-by-phone.p (father-of.p)]

Computational vs representational evaluation of terms Recall: terms formed from symbols, strings, and numbers, composed using functions and set and sequence operators Strings always evaluate to themselves Numbers also Symbols evaluate to themselves computationally, and to a thing in the world representationally (modif. will follow) Set and sequence expressions evaluate element by element Functions evaluate using knowledgebase computationally Functions representationally: according to facts in the world if some argument is in the world, otherwise use computational evaluation (modif. will follow)

The examples Terms: (+.a 5) (father-of sven) (age (father-of sven)) Proposition: [less-than (age (father-of sven)) 50] Actions: [call-by-phone sven (father-of sven)] [call-by-phone.p (father-of.p)] Consider the arguments of the action expressions. - Computational evaluation: symbols sven, lars - Representational evaluation: these respective persons Function 'age' maps - Computationally: symbol to number - Representationally: person to number Analyze function 'father-of' similarly Function + maps number to number in both modes

Additional examples [member sven (friends-of gunnar)] [member sven {maria sture hubert... }] Notice that literals (i.e. elementary propositions) evaluate similarly to functions, but they have a truth-value Composite propositions, formed using and, or, not, etc, also evaluate similarly to functions, with standard truth-tables 'Numbers evaluate to themselves': a mathematician make take issue on this, and the system implementor as well, but for our purpose it is sufficient 'Set expressions evaluate to themselves': similar observation

Evaluation vs execution of actions (More exactly, action expressions) Evaluation of action: arguments and parameters elementwise, like for sets and sequences Execution of (evaluated) action: computationally in simulated world, representationally in real world A robot will do computational evaluation followed by representational execution (leads to grounding problem) Examples: [call-by-phone sven (father-of sven)] [call-by-phone.p (father-of.p)] Evaluation result: [call-by-phone sven lars-erik]

Execution vs statements about actions Examples: [call-by-phone sven (father-of sven)] [call-by-phone.p (father-of.p)] Evaluation result: [call-by-phone sven lars-erik] Actually in the world: representational evaluation and execution Performed by robot: comput. evaluation, repres. execution (modif. example as [call-by-phone sven (father-of sven)] ) In memory: use a proposition like [do time-4983 time-4992 [call-by-phone sven lars-erik]] In a plan: similarly (but ending time yet undetermined)

Computational evaluation of terms and propositions Possibilities: One attached procedure for each function and predicate, without stored data (examples: plus, less-than, concat) Make a table of argument combinations and corresponding values, for each function and predicate For predicates: make a list of those combinations of arguments where it is true, omit the others Representation using attribute values of one or more of the arguments, for example [are-friends lars sven] using a set- valued attribute for one or both of the arguments

Correspondence between a symbol and its representational value The following conventions are sometimes applicable: Unique names assumption: Never two different symbols that have the same representational value in the 'world' Closed world assumption: Each thing in the 'world' has a symbol whose representational value it is. Called closed world assumption because... Modified unique names assumption: make statements [equal foo fie] in those cases where two symbols refer to the same thing. If no such statement is in the knowledgebase, then take for granted that they refer to two different things.

Composite entities Compare the following representations, where area1 and area2 are given entities: [has-type border-area1-area2 border] [delimits border-area1-area2 area1] [delimits border-area1-area2 area2] [marked-by border-area1-area2 wooden-fence] [marked-by (border-between area1 area2) wooden-fence] [marked-by (border-between area1 area2)(made-by fence wood)] where also [subsumed-by wooden-fence fence] [material-for wooden-fence wood]

Use of composite entities Convenient both notationally and implementationwise May apply to specific things, e.g. area1, or to classes or other abstract entities, e.g. fence Do not admit multiple values, but may have a set as a value. (What about occasional multiple values?) Must use a reserved value such as nil when no actual value exists Equality issue is important when composite entities are used. Example: lars-erik vs (father-of sven) vs... One may wish to use unique names assumption for atomic entities only

Reification Compare [has-phonenumber sven " "] [equal (phonenumber sven) " "] [Holds (phoneof: sven) " "] The third construct allows you to also write e.g. [knows lars (phoneof: sven)] The entity (phoneof: sven) is called a reification The function the complements Holds, for forming subexpressions, as in [equal (the (phoneof: sven)) " "] Reifications are usually subject to a complete unique names assumption If phone number is time dependent, then make time an additional argument of phonenumber, the, and Holds

List Processing in CEL Operations on recursively nested sequences, called lists Functions: (e1 ) = a (e2 ) = b etc (en 4 ) = d (t1 ) = (t2 ) = (cons a ) = (concat ) =

Information aggregates Information elements, in different approaches: - Logic programming: propositions - OWL: triple of entities - KRF: an entity with its attribute values Information aggregates are the structures that are used for organizing large numbers of information elements In KRF: entityfiles, knowledgeblocks, agents, individuals An entityfile is a textfile containing a sequence of entity descriptions A knowledgeblock is a set of entityfiles Each agent contains a number of knowledgeblocks, and may also access knowledgeblocks of other agents in the same individual, to a limited extent

Lab2a addresses information aggregates and representation issues

Introduction to KR framework Knowledge Representation (several parts) Leonardo installation Software for Intelligent Agents Managing Info Aggregates Goals of AI Logic notes Leonardo Document:n Programming Language Lisp Lisp in Leo Environment Leonardo Facilities List Processing Reading Matter for the course

List processing Recursively nested sequences as the only composite expressions, with symbols, strings, numbers as elements Functions on sequences (no side-effects!) (e1 ) = a (e2 ) = b (en 4 ) = d (t1 ) = t2, tn similarly (cons g ) = Notice: (cons (e1.x) (t1.x)) = x

List processing Predicates on lists (equal ) = true Control operators, for example (if (equal.a <>).b.a) Other necessary function (type-of.a) The value is either symbol, string, integer, real, sequence Other functions can be defined in terms of these, for example and, or, not

List Processing - Recursive Functions (length.s) == (if [equal.s <>] 0 (+ 1 (length (t1.s)))) (replace.a.b.s) == (if [equal.s.a].b (if [atom.s] s (cons (replace.a.b (e1.s)) (replace.a.b (t1.s)) )))

Lisp Programming Lisp uses S-expression style, all data are formed as recursively nested expressions with round parentheses Using function names such as e1 and t1, rewrite as follows (e1 ) (e1 (quote (a b c))) ssv.a (setq a (quote (red green))) (e1.a) (e1 a) General rule: a list (g a b c) is considered as a term with g as a function and the rest as arguments, except for a small number of special operators, such as quote, if,... This results in the simplest possible system, but at some expense of readability. KRE / CEL is closer to the standard notation of logic and mathematics.

Lisp Systems - Data Structure (red green blue) represented as red nil bluegreen The e1 and t1 operations follow a pointer (but they are actually called car and cdr in Lisp) The cons operation constructs a new 'yellow' cell This was the origin of the method of garbage collection.

What datastructure for KRE? One possibility: reimplement from scratch (not a very attractive idea) Other possibility: implement "on top of" Lisp (or another similar language). This is a standard approach in the field. Lisp is used as a "high level implementation language". Other languages that are similar to Lisp and that are well suited for the same purpose: Scheme (also S-expression style), Python.

List Processing - Recursive Functions (length.s) == (if [equal.s <>] 0 (+ 1 (length (t1.s)))) (replace.a.b.s) == (if [equal.s.a].b (if [atom.s] s (cons (replace.a.b (e1.s)) (replace.a.b (t1.s)) )))

Information aggregates, continued Working with entityfiles Commands: crek zoo-kb create new knowledgeblock, directory Zoo setk zoo-kb select as current knowledgeblock crefil animals-catal create entityfile in this block loadfil animals-catal load the textual file into session writefil animals-catal write back textual file from session loadk zoo-kb loadfil zoo-kb + loadfil of its 'mustload' For lab2a, recommended to work in 'loadfil mode': text-edit the file and load it from time to time For some purposes the 'writefil' mode is appropriate Directory Zoo contains entityfile zoo-kb which contains info about the other entityfiles in the knowledgeblock

Small Example demofil [: type entityfile] [: latest-written " /07:46.+02"] [: contents ] [: changed-since-archived t] Groucho [: type animal] [: in-species gorilla] [: sex male] [: has-age 15] ooooooooooooooooooooooooooooooooooooooooooooooooooooooooo

Small Example - Type definition ontofil [: type entityfile] [: latest-written " /07:38.+02"] [: contents ] [: changed-since-archived t] animal [: type Type] [: attributes {in-species sex has-age}] ooooooooooooooooooooooooooooooooooooooooooooooooooooooooo

Small Example - Technical additions demofil [: type entityfile] [: latest-written " /07:46.+02"] [: contents ] [: changed-since-archived t] [: nullvalued {has-purpose has-author requires mustload leos-extension has-profile overlay-on overlay-types overlay- own leos-use dont-display sections local-ents purpose author latest-archived-entity latest-rearchived}] Groucho [: type animal] [: in-species gorilla] [: sex male] [: has-age 15] [: latest-rearchived nil] ooooooooooooooooooooooooooooooooooooooooooooooooooooooooo