12.2 Symbols and Semantics

Chapter 5 was about reasoning with symbols that represent propositions. In this section, we expand the semantics to reason about individuals and relations. A symbol will denote an individual or a relation. We still have propositions; atomic propositions now have internal structure in terms of relations and individuals.

Figure 12.1: The role of semantics. The meaning of the symbols are in the user's head. The computer takes in symbols and outputs symbols. The output can be interpreted by the user according to the meaning the user places on the symbols.

Figure 12.1 illustrates the general idea of semantics with individuals and relations. The person who is designing the knowledge base has a meaning for the symbols. The person knows what the symbols kim, r123, and in refer to in the domain and supplies a knowledge base of sentences in the representation language to the computer. These sentences have meaning to that person. She can ask questions using these symbols and with the particular meaning she has for them. The computer takes these sentences and questions, and it computes answers. The computer does not know what the symbols mean. However, the person who supplied the information can use the meaning associated with the symbols to interpret the answer with respect to the world.

The mapping between the symbols in the mind and the individuals and relations denoted by these symbols is called a conceptualization. In this chapter, we assume that the conceptualization is in the user's head, or written informally, in comments. Making conceptualizations explicit is the role of a formal ontology.

Relationships to Traditional Programming Languages

The notion of logical semantics presented in this chapter should be contrasted with the procedural semantics of traditional programming languages like Fortran, C++, Lisp, or Java. The semantics for these languages specify the meaning of the language constructs in terms of what the computer will compute based on the program. This corresponds more closely to the proof theory presented here. Logical semantics gives a way to specify the relationships of the symbols to the world, and a way to specify the result of a program independently of how it is computed.

The definitions of semantics and reasoning theory correspond to the notions of a Tarskian semantics and proof in mathematical logic. Logic allows us to define knowledge independently of how it is used. Knowledge base designers or users can verify the correctness of knowledge if they know its meaning. People can debate the truth of sentences in the language and observe the world to verify the statements. The same semantics can be used to establish the correctness of an implementation.

The notion of an individual is similar to the definition of an object in object-oriented languages such as Smalltalk, C++, or Java. The main difference is that the objects in object-oriented languages are computational objects rather than real physical objects. In an object-oriented language, a "person" object is a representation of a person; it is not the actual person. However, in the representation and reasoning systems considered in AI, an individual "person" can denote the actual person. In object-oriented languages, objects send each other messages. In the logical view, not only do we want to interact with objects, but we also want to reason about them. We may want to be able to predict what an object will do without getting the object to do it. We may want to predict the internal state from the observed behavior, for example, in a diagnostic task. We even want to reason about, and predict the behavior of, individuals who may be deliberately concealing information and may not want us to know what they are doing. For example, consider a "person" object: although there can be some interaction with the person, there is often much information that we do not know. Because we cannot keep asking them for the information (which they may not know or may not want to tell us), we require some external representation of the information about that individual. It is even harder to interact with a chair or a disease, but we still may want to reason about them.

Many programming languages have facilities for dealing with designed objects, perhaps even with a single purpose in mind. For example, in Java, objects have to fit into a single class hierarchy, whereas real-world individuals may have many roles and be in many classes; it is the complex interaction of these classes that specifies the behavior. A knowledge base designer may not know, a priori, how these classes will interact.

Under this view, what is the correct answer is defined independently of how it is computed. The correctness of a knowledge base is defined by the semantics, not by a particular algorithm for proving queries. As long as the inference is faithful to the semantics, the proof procedure can be optimized for efficiency. This separation of meaning from computation lets an agent optimize performance while maintaining correctness.