Like this presentation? Why not share!

# Semantics

## by Mohammed Al-Meqdad, Teacher of English for non-specialists at Damascus University on Jan 01, 2012

• 590 views

### Views

Total Views
590
Views on SlideShare
590
Embed Views
0

Likes
0
Downloads
20
Comments
0

No embeds

### Upload Details

Uploaded via SlideShare as Microsoft PowerPoint

### Usage Rights

© All Rights Reserved

### Report content

Edit your comment

## SemanticsPresentation Transcript

• Syntax, Semantics and Intended Meaning The 1-slide course
• Syntax
• Symbols + a set of rules for their valid composition into aggregate structures
• Semantics
• The relationship between syntactic structures of a symbol system and what they are intended to denote -- their intended meaning
• Intended Meaning
• A set of truths, T, about some world
• Source is external to the symbol system
• Represented in the sy mbol system by syntactic structures (S 1 ,…S n )
• The system is “good/useful/fruitful/meaningful” if
• All truths in T may be represented by some S i ( complete )
• Every S i entailed by the system represents some truth in T ( sound )
• LP Syntactic Structures
• Terms
• Constant, Variable, Functor, Term, Compound Term
• Instances
• Substitution, Instance
• Facts and Queries
• Facts and the rule of instantiation
• Queries and the rule of generalization
• Rules and Logic Programs
• Rules, Unification, Logic Programs
• Term The single data structure
• Constant
• letter, number, string of letters or numbers beginning with a lower case letter.
• Intended to represent entities, individuals, existent etc. : dog, cat, alfred, r2d2, selmer, the number 2 .
• Variable
• Capital letter, or string of letters or numbers beginning with a capital letter
• Intended to represent an “yet to be identified/deduced” constant.
• Operationally: “Write Once, Ready Many”. Once found truth can not be unfound.
• Compound term
• Functor(A 1 ,…,A n )
• Functor is any constant
• A i is a term.
• Intended to represent relations or predicates about things: father(selmer,r2d2).
• Substitution A formal definition
• A finite set of pairs of the form x i = t j , where
• x i is a variable
• t i is a term
• x i < > x j for every i < > j
• variables are bound only once in the substitution
• x i does not occur in t j , for any i and j.
• no recursive references in a binding
• Substitutions can be applied to terms
• foo(X,Y) {X=selmer,Y=r2d2}  foo(selmer, r2d2).
• Instances A relationship between terms
• One term may be an instance of another term.
• A is an instance of B if
• There exists a substitution q such that A=B{q}
• Think of a substitution as a set of variable bindings
• Examples
• 1 is an instance of X.
• The substitution is {X=1}
• foo(bar,1) is an instance of foo(V,1)
• the substitution is {V=Bar}
• father(big_Tony,franky_three_shots) is an instance of father(X,Y)
• What is the substitution?
• A ground instance is an instance with NO variables
• foo(V,Y){V=bar) = foo(bar,Y) is NOT ground.
• foo(V,Y){V=bar, Y=1) = foo(bar,1) is ground.
• Queries
• A compound term preceded by ‘ :- ‘
• :- functor(t 1 ,…,t n )
• Variables are existentially quantified
• Example
• LP: :- father(big_Tony,X)
• FOL:  x father(big_Tony, x)
• English:
• Is Big Tony anyone's father?
• Does there exist a thing, X, such that Big Tony is the father of X?
• Rule of Generalization
• An existential query P is a logical consequent of an instance of P, P{q}, for any substitution q.
• Example
• :- father(big_Tony, X) is a logical consequent of
• father(big_Tony, two_Ton_Tommy)
• Different ways of saying the same thing
•  X | p(X) is true if p(anything here) is true.
• The existential generalization is true if an instance of it is true.
• A Fact
• Compound Term
• Functor(t 1 ,…,t n )
• Variables are universally quantified
• father(big_Tony, X) means
• English : big Tony is everyone’s father
• FOL :  (X) father(big_Tony,X)
• Rule of Instantiation
• From a universally quantified statement P (i.e., a fact ) deduce an instance of it, P{q}, for any substitution q.
• From father(big_Tony,X) deduce
• father(big_Tony, two_Ton_Tommy),
• father(big_Tony, selmer),
• father(big_Tony, franky_Three_shots),
• father(big_Tony, r2d2) …
• A Rule
• Complex query composed of simpler queries
• Has a head (a term) and a body (a sequence of terms)
• H  B 1 ,…,B n
• A fact is a rule where n=0
• Example
• LP: grandmother(X,Z)  mother(X,Y), mother(Y,Z).
• FOL:  (X,Y,Z) mother(X,Y) ^ mother(Y,Z)  grandmother(X,Z)
• English: A person who is the mother of another person who is herself the mother of a third person is the grandmother of the third person
• Which representation do you prefer?
My best attempt at communicate meaning is by offering yet another syntactic structure form some other symbol system with yet another semantics that I hope my audience understands. Where is meaning ultimately captured? Is it captured at all? We gather evidence that expressions in one system align with expressions in another. At some point we agree that we understand each other. But do we? Have we capture meaning or just aligned expressions in different symbol systems to realize functional communication? Does the meaning of the American word love have a direct analog in Latin?
• Rule of Universal Modus Ponens
• From
• A  B 1 ,…,B n  (B` 1 ,…,B` n )
• where for all i between 1 and n, B` i is an instance of B i
• A` is an instance of A
• Deduce
• A`
• From
• grandfather(X,Z)  father(X,Y), father(Y,Z)
• father(big_Tony, little_Tony), father(little_Tony, tiny_Tony)
• Deduce
• grandfather(big_Tony, tiny_Tony)
• A Logic Program
• A logic program is a finite set of rules.
• Example Logic Program: The “Family” Tree
• father(big_Tony, little_Tony).
• father(little_Tony, tiny_Tony).
• boss(quick_Nick, franky_three_shots).
• boss(buddy_the_button, mikey_the_mop).
• boss(big_tony,Y)  boss(Y,Z).
• grandfather(X,Z)  father(X,Y), father(Y,Z).
• Example Queries
• :- boss(big_Tony, quick_Nick)
• yes
• :- boss(big_Tony, r2d2)
• no….why? What’s the intended meaning of the boss(big_tony_Y) rule above?
Facts are rules where the body is empty. Rules with bodies
• More on Semantics Declarative and Operational
• Declarative Semantics What it means is what it is .
• How a the syntactic structure of a program relates to its intended meaning
• The meaning of a logic program is the set of all the statements it entails
• The meaning of a logic program P is the minimal model for P
• where the minimal model for P is the intersection of all models of P,
• where a model of P is an interpretation , I, for P where, for every ground instance of a clause A  B in P, A is in I if B is in I
• where an interpretation is a subset of the Herbrand Base
• where the Herbrand Base is the set of all ground goals that can be formed (syntactically) form the predicates in P and the terms in the Herbrand Universe
• where the Herbrand Universe is the set of all ground terms that can be formed from the constants and function symbols appearing in P.
• Operational Semantics What it means is what a procedure produces.
• The meaning of a logic program, P, is the set of ground goals that are instances of queries produced by P according to a LP computation .
• A computation of a program P is a procedure .
• The procedure starts with a query G, progresses via goal reduction and it either succeeds , fails or never terminates .
• If it succeeds then the instance of G produced is in the meaning of P.
• If it fails then no instance of G is in the meaning of P.
• If it never terminates , then we don’t know if any instance of G is in the meaning of P.
• How does goal reduction produces statements (i.e., answers)?
• How it works is the operational semantics of logic programming.
• The meaning is the output of the procedure. The operational semantics is a formal description of the procedure for producing the output from the input.
• Classic Programming Languages
• What are the declarative semantics?
• Scott-Strachey approach to programming language theory
• Denotational Semantics (book by Joseph Stoy)
• Lambda Calculus (dates back to Lisp in the 1950’s)
• Concept: Given a program, P and the environment, E (contents of the registers of the machine or of variable/value bindings), there is a formal theory for logically deducing the “next environment” -- the environment that is entailed by P + E.
• What are the operational semantics?
• How the compiler processes the program to determine the assignment of variables to values.
• Goal Reduction The computational core of LP
• Elements of Goal Reduction
• Unification Pattern Matching
• Resolution Inference
• Chronological Backtracking Search
• Unification
• A constructive pattern matching procedure
• Determines the most general unifier (MGU) of two terms.
• Using the MGU constructs the most general common instance of two terms
• Used to compute the resolution inference
• Resolution is used to iteratively reduce a goal generating its proof from the program if possible (i.e., goal reduction)
• Most General Unifier(MGU)
• A common instance of A and B is an instance of both A and B.
• foo(1,2) is a common instance of foo(1,Y) and of foo(X,2)
• A unifier of two terms is a substitution that renders the terms identical
• {X=1,Y=2} applied to foo(1,Y) and to foo(X,2) produces identical terms
• The MGU of two terms is a unifier that produces the most general common instance of the two terms.
• Which are instances of both foo(X,Y), foo(1,Y)? What is the MGU?
• bar(1, 2)
• foo(A, 1)
• foo(A, B)
• foo(1, 2)
• foo(1, B)
None, None {X=A, Y=1}, None {X=A, Y=B}, None {X=1,Y=2}, {Y=2} {X=1,Y=B}, {Y=B}
• Unification Procedure
• Computes the MGU of two terms if it exists else fails.
• unify(X,1) {X,1}
• unify(a(X,1), a(1,Y)) {X=1, Y=1)
• Produces the most general common instance
• If two terms unify it is NOT necessarily the case that one is an instance of the other
• a(X,1) is not an instance of a(1,Y)
• a(1,Y) is not an instance of a(X,1)
• Unification Examples
• Fact Schema: Supports(Video_Card, Display_Type, Number_of_Colors)
• Example 1: Neither A nor B entails the other
• Facts (A and B): supports(V,b14,C), supports(nvidia,D,256)
• MCI : supports(nvidia, b14, 256)
• MGU : {V=nvidia, D=b14, C=256)
• Example 2: B is an instance of A
• Facts (A and B): supports(V,b14,C), supports(rage,b14,16)
• MCI : supports(rage, b14, 16)
• MGU : {V=rage, C=16}
• Example 3: A and B are not unifiable
• Facts (A and B): supports(V,b14,16), supports(nvidia,D,256)
• MCI : None
• MGU : None
• Resolution
• Enables a reduction of two rules into one
• Eliminates a common term from the consequent of one rule and from the antecedent of another
• Efficient application depends on the constructive unification procedure
• General Form:
• Rule 1: A  (B ^ M)
• Rule 2 : (C ^ N)  D
• Resolution Inference: (A ^ C)   (B ^ D) 
• where  is the MGU of M and N.
• Resolution Example
• Rule 1
• affinity(Y,Z) :- likes(Y,Z), even(Z).
• Rule 2
• basic_affinity(Y) :- affinity(Y,2)
• Inference:
• basic_affinity(Y) :- likes(Y,2), even(2).
• The inference allowed the
• elimination of affinity (Y,Z) and
• reduction to a single rule through finding
• the MGU of af finity ( Y ,Z) and af finity ( Y` ,2 ) and
• applying it to the body of rule 1.
• What fact would make :- basic_affinity(r2d2) true?
• Chronological Backtracking
• A search procedure for finding unifying terms
• Conducted over an explicit set of clauses
• Upon failure (a “dead-end”) previous variable bindings are chronologically unwound and the search begins again until all possible bindings are exhausted
• Note
• Fruitful bindings may be unrelated to chronology
• Can therefore be terrible inefficient
• Must be aware of how this works to write efficient LPs
• Backtracking Example
• plugsIn(X,Y) :-
• outPort(X),
• inPort(Y),
• compatible(Y,Y).
• inPort(in1).
• inPort(in2).
• inport(in3).
• outPort(o5).
• compatible(o5,in3).
• :- plugsIn(X,Y)
• outPort(o5)
• inPort(in1)
• compatible(o5,in1)
• FAIL and Backtrack
• inPort(in2)
• compatible(o5,in2)
• FAIL and Backtrack
• inPort(in3)
• compatible(o5,in3)
• Success(1). plugsIn(o5,in3).
• inPort(Y)
• FAIL and Backtrack
• outPort(X)
• FAIL
Search order matters. Put compatible first in the plugsIn rule?
• Practical Introduction to Prolog Basics
• Programming Excursions
• Exploring Unification
• Basic Constructs
• Arithmetic, Recursion and Lists
• Database Programming
• Trees and Parsing
• Practical Introduction to Prolog Negation and the Cut