an application of prolog logical inference with an interface

06-25433 – Logic Programming

An application of Prolog

Logical inference with an interface

This lecture will cover:.

– making logical inferences from new facts;

– using CHR to implement an inference system;

– providing an interface to the inference system using a DCG.


13 - An application of Prolog: Logical inference with an interface 1

Last time: DCGs

DCGs are a powerful and convenient implementation of CFG in Prolog.

They allow rules which specify

– structure building

– arbitrary embedded Prolog code

Because DCGs use Prolog’s depth-first search, they have problems with left-recursive rules – but this can be eliminated.

DCGs are more than a language parsing tool – they have uses in a wide variety of programs.



DCGs: a reminder - 1

Consider the problem of finding the sublists of a list:

| ?- sub_string([a,b,c,d,e], Sub_String).

Sub_String = [a,b,c,d,e] ? ;

Sub_String = [b,c,d,e] ? ;

Sub_String = [c,d,e] ? ;

Sub_String = [d,e] ? ;

Sub_String = [e] ? ;

Sub_String = [] ? ;

no




This can be written in “normal” Prolog:

% 1 – a list is a sub-list of itself

sub_string(List, List).

% 2 – a sub-list is in the tail

sub_string([_|List], Sub_List) :-

sub_string(List, Sub_List).




Or it can be written in DCG notation:

% 1 – a list is a sub-list of itself

sub_string -->

[].

% 2 – a sub-list is in the tail

sub_string -->

[_],

sub_string.



Simple inference

The simplest rule of inference: modus ponens.

The truth table:

P Q P → Q

t t t

t f f

f t t

f f t

if X is_father_of Y then Y is_child_of X

X is_father_of Y

Y is_child_of

X



Simple inference

The simplest rule of inference: modus ponens.

The truth table:

P Q P → Q

t t t

t f f

f t t

f f t


Henry is_father_of

Mary

Mary is_child_of

Henry



Simple inference in Prolog is not simple

This looks easy to write in Prolog:


is_child_of(Child, Parent) :-

is_father_of(Parent, Child).

with this fact in the database: is_father_of(henry, mary).

and the query: | ?- is_child_of(Child, Father).




There are two ways of running this rule:

Backward chaining:

• start with the goal and then look for evidence …

• work from the consequent (i.e. the conclusion) to the antecedents (i.e. the evidence).

• this is Prolog’s model of reasoning.

Good if you have the evidence and an hypothesis.




Forward chaining:

• start with the evidence and then look for conclusion(s) …

• work from the antecedents (i.e. the evidence) to the consequent (i.e. the conclusion).

• this is the opposite of Prolog’s model of reasoning.

Good if you have the evidence but no hypothesis.




We often want to use forward chaining – we combine new information with old information to produce new ideas.

It is possible to write a forward chaining inference engine in Prolog – see the module WWW page for a link.

But there is an easier way …



Constraint Handling Rules (CHR) - 1

It is easy to use Prolog as an implementation language for other languages – and then you can run them within Prolog without any difficulty…

CHR is a programming language for writing constraint processors.

A constraint is only a relationship that should hold between arguments: parent(Child, Mother, Father).




In CHR, constraints are Prolog-like structures.

Constraints are held in the central constraint store.

The store is a (logically) unordered heap.

Constraints are posted to the global store.




CHR is a concurrent programming language.

Concurrent means that it can have one or more processes running at the same time.

The (rough) idea is that each process runs in parallel on their own processor.

Individual processes communicate and share information through shared logical variables.




In practice, we write rules that specify how to process constraints.

These rules act like processes that are run as soon as their constraints are satisfied.

Each rule runs as soon as it can – so if something happens to satisfy two rules – both are fired concurrently.

The programmer doesn’t have to tell CHR when to fire a rule.



Inference in CHR

This is the rule for being a mother:

parent(Mother, Child, _),

female(Mother, _) ==>

mother(Mother, Child, system).

This reads:

if parent(M, C) and female(M) then infer

mother(M, C).

Note that CHR allows more than one constraint in the head of the rule.



Coding in CHR

Some constraints are:

– child(mary, henry, system)

– father(henry, mary, system)

– female(mary, user)

– male(henry, user)

– parent(henry, mary, user)

system and

user shows

whether the

constraint has

been added by

user input or

inferred by the

system.



Part of the Tudor family tree



Using inference rules

parent(Father,Child,_),male(Father,_) ==>

father(Father, Child, system).

parent(Parent, Child, _) ==>

child(Child, Parent, system).

female(Sister, _) ==>

sister(Sister, Sibling, system).

half_sibling(Sister, Sibling, _),

female(Sister, _) ==>

half_sister(Sister, Sibling,system).

Demo 1



What is this application?

The application is

– a natural language interface to a knowledge base

– with an inference system to infer new knowledge

The knowledge domain is family relationships, e.g.

– parent

– mother

– sibling

– step-brother, …



What could we use this for?

One use would be to learn information from texts so it can be used to answer questions …

For instance, IBM’s Watson system:

http://www.youtube.com/watch?v=WFR3lOm_xhE

Watson has about 50,000 lines of Prolog code.

http://www.youtube.com/watch?v=WFR3lOm_xhE



An example of the system in action - 1

The input is: “Henry VIII is male”

Input text: [henry8, is, male].

Syntax: s(np(propn(Henry VIII)),

vp(is,adj_p(adj(male))))

Semantics: male(Henry VIII,user)

Knowledge store

-----------------------------------------

male(Henry VIII,user)

-----------------------------------------




The next input is: “Henry VIII is the parent of Mary Tudor”

Input text: [henry8, is, the, parent, of, mary].

Syntax: s(np(propn(Henry VIII)),

vp(is,

np(det(the),noun(parent)),

pp(prep(of),

np(propn(Mary Tudor)))))

Semantics: parent(Henry VIII,Mary,user)




The knowledge store has facts added by the user and inferred by the system:

Knowledge store

-----------------------------------------

male(Henry VIII,user)

parent(Henry VIII,Mary,user)

child(Mary,Henry VIII,system)

father(Henry VIII,Mary,system)

-----------------------------------------



A natural language interface - 1

In the following, we’ll see how reasoning can be linked to a natural language interface.

We will use syntax to ensure that our sentences are well-formed and use a simple semantic structure to provide facts for the inference engine.

Our semantic structure has the basic form of:

– predicate

– one or more arguments



A natural language interface - 2

Examples of semantic structure

– male(‘Henry VIII’, user)

– parent(‘Henry VIII’, ‘Mary’, system)

In other words, the semantic structures are the CHR constraints.



Adding semantics

We need to map from the input words to semantic representation.

Syntax guides this process:

• it picks out the “action/state” of the sentence to become the predicate of the semantic structure:

• Henry is male male(henry)

• it shows what fills which arguments:

• Jane hits John with the club hits(jane, john, club)



Building the semantic structures

Building semantic structures is not for beginners!

The standard technique:

• uses lambda calculus (Models of Computation) to put variables into the correct slots;

• pattern matching (because assignment won’t work here).

All will be revealed in Natural Language Processing 1



How do the interface

and inference engine communicate?

The answer is very simply.

The output of the interface is a semantic structure, e.g.: parent('Elizabeth of York',

'Henry VIII', system)

female('Elizabeth of York', system)

These are simply posted to the store.



How do the interface

and inference engine communicate?

Posting to store is simply done by parsing an input then “running” the semantics:

| ?- s(Tree, Sem, [henry8,is,male], []),

Sem.

Sem = male('Henry VIII',user),

Tree = s(propn('Henry VIII'),

vp(is,adj_p(adj(male)))),

male('Henry VIII',user) ? ;

no Demo 3



The significance of this system

Inference (in Prolog or CHR) is used in a wide range of applications - configuring telephone systems, reasoning about security access, controlling Java concurrency.

DCGs can be used for describing structured data - and writing simpler list processing programs.

The NL interface could be developed to answer questions, to accept new rule definitions, to understand questions about all, some, how many etc.

an application of prolog logical inference with an interface

Documents