Proof System

1
Proof System

• HY-566

2
Proof layer

• Next layer of SW is logic and proof layers.
• allow the user to state any logical principles,
• computer can to infer new knowledge by applying
  these principles on the existing data.
• This project implements a defeasible reasoning
  system which presents explanations to users for
  the answers to their queries.

3
Defeasible Logic

• A defeasible theory is a triple (F, R, gt)
• F is a set of literals (called facts)
• R a finite set of rules
• gt a superiority relation on R
• Two kind of rules
• Strict rules (A?P) cant be defeated
• Defeasible rules (AgtP) can be defeated

4
Defeasible Logic Metaprogram

• Simulates the proof theory of defeasible logic
  contains clauses
• denite provability
• defeasible provability
• When rule is blocked/unblocked
• When rule is defeated/undefeateds

5
Explanation Example

• An e-shop tell to Bobs that he owns 30
• Explanation (facts and rules)
• purchase(Bob,DVD) - fact
• price(DVD,30) - fact
• delivered(DVD,Bob) - fact
• purchase(Bob,DVD), price(DVD,30),
  delivered(DVD,Bob) ? owes(Bob,30) - rule

6
Extension of RULML

• RuleML is an XML based language that supports
  rule representation for the Semantic Web.
• A new XML schema, extension of RuleML, is
  proposed for explanation representation in
  defeasible logic

7
Ext. RULML - Atom, Fact

• Atom operator, var or const, optionaly NOT
• ltAtomgt
• ltNotgt
• ltOpgt rich lt/Opgt
• ltIndgt Bob lt/Indgt
• lt/Notgt
• lt/Atomgt
• A Fact is consisted by an Atom that comprise a
  certain knowledge

8
Ext. RULML - Rules

• Strict - Defeasible Rules.
• Head is an Atom
• Body number of Atoms

ltDefeasible_rule Label"r1"gt ltHeadgt
ltAtomgt ltOpgt rich lt/Opgt ltIndgt
Bob lt/Indgt lt/Atomgt lt/Headgt
ltBodygt ltAtomgt ltOpgt wins_lotto
lt/Opgt ltIndgt Bob lt/Indgt lt/Atomgt
lt/Bodygt lt/Defeasible_rulegt
9
Ext. RULML - Explanations

• Definitely Provable Explanations
• Denote the Atom
• Definite Proof
• Definite Proof
• Fact for that Atom
• Strict Rule with Head the Atom and Body
  (multiple) atoms that must be proved definitely.

10
Explanations Example

• ltDefinitely_provablegt
• ltAtomgt
• ltOpgt rich lt/Opgt
• ltIndgt Bob lt/Indgt
• lt/Atomgt
• ltDefinite_Proofgt
• ltStrict_rule Label"r1"gt
• ltHeadgt
• ltAtomgt
• ltOpgt rich lt/Opgt
• ltIndgt Bob lt/Indgt
• lt/Atomgt
• lt/Headgt
• ltBodygt
• ltAtomgt
• ltOpgt wins_lotto lt/Opgt

• ltIndgt Bob lt/Indgt
• lt/Atomgt
• lt/Bodygt
• lt/Strict_rulegt
• ltDefinitely_provablegt
• ltDefinite_Proofgt
• ltFactgt
• ltAtomgt
• ltOpgt wins_lotto lt/Opgt
• ltIndgt Bob lt/Indgt
• lt/Atomgt
• lt/Factgt
• lt/Definite_Proofgt
• lt/Definitely_provablegt
• lt/Definite_Proofgt
• lt/Definitely_provablegt

11
Other Explanations

• Defeasibly Provable Explanations
• arises from the defeasible logic specification.
• Not Definitely Provable Explanations
• consists of all the strict rules with head equal
  to the negation of the non provable Atom
• Not Defeasibly Provable Explanations
• arises from the defeasible logic specification

12
Proof tree construction (1/3)

• The foundation of the proof system
• Prolog metaprogram implements rules of Defeasible
  Logic
• The trace of the XSB implementation of prolog
• XSB logic programming engine used to run the
  metaprogram.
• To communicate with the XSB the invocation of the
  XSB executable was used (Javas exec method)
• Send commands to the XSB interpreter
• Receive the output that was produced as an
  effect.
• Load the metaprogram and the defeasible theory

13
Proof tree construction (2/3)

• Load the metaprogram and the defeasible theory
• At the evaluation of a query XSB will print a
  message each time a predicate is
• Initially entered (Call)
• Successfully returned from (Exit),
• Failed back into (Redo), and
• Completely failed out of (Fail).

14
Proof tree construction (3/3)

• A tree whose nodes are traced predicates is
  constructed by the Java XSB invoker when trace is
  parsed.
• Each node has information
• A string for the predicates name
• The predicates arguments
• Whether it was found to be true (Exit) or false
  (Fail)
• Whether it was failed back into (Redo)
• Boolean attribute tells if predicate is negated.

15
Why the tree needs pruning?

• XSB trace contains data not needed for proof
• A metaprogram to translate the DL into logic
  programming is used. Additional clauses are
  needed which add information to trace
• Prolog shows successful and unsuccessful paths
• The tree produced by the XSB trace is built
  according to the metaprogram structure but the
  final tree needs to be compliant with the XML
  schema

16
Pruning Rules

• Heuristic rules are used in order to prune the
  proof tree
• According to the truth value and the type of the
  root node we may want to maintain
• only successful paths
• only failed paths
• combinations of them.

17
Pruning Motivation Example1

• Suppose we have the following defeasibly theory
  translated in logic programming as
• fact(a).
• fact(e).
• defeasible(r1,b,a).
• defeasible(r2,b,e).
• defeasible(r3,(b),d).

18
Example1 Defeasible provability of b
Pruned
19
Example1 Defeasible provability of b

• We are interested in successful (True) paths
• The pruning algorithm removes
• the subtree with the false goal to prove that b
  is denitely provable
• the false predicate to find a strict supportive
  rule for b
• the metaprogram additional negation clause.

20
Pruning Motivation Example2

• Suppose we have the following defeasibly theory
  translated in logic programming as
• fact(a).
• defeasible(r1,b,a).
• defeasible(r2,(b),a).

21
Example2 Defeasible provability of b
We are interested in unsuccessful paths and the
pruning algorithm keeps the initial proof tree.
22
Pruning resume

• The proof tree after using the heuristic
  techniques is similar to an explanation derived
  by the use of pure DL
• Drawback heuristics are fully dependent on the
  metaprogram.
• Changes at metaprogram gt changes at pruning
  implementation.

23
Pruning Example
The marked rule is pruned
24
Pruning Example 2
The marked rule is pruned
25
Agent Interface to the Proof System

• The system makes use of two kinds of agents
• 'Agent' which issues queries
• 'Main Agent' which is responsible to answer the
  queries.
• Both agents are based on JADE (Java Agent
  DEvelopment Framework)
• a software framework to develop agent-based
  applications

26
Process to answer a query (1/3)
27
Process to answer a query (2/3)

• An agent issues a query to the Main Agent.
• predicate(proofanswer)
• Main Agent sends Predicate to the Invoker
• Invoker is responsible to communicate with XSB
• Invoker executes the Predicate.
• XSB returns the full result trace.
• Invoker returns result tree to Main Agent.
• Main Agent sends result tree to the Pruner

28
Process to answer a query (3/3)

• Pruner returns pruned result to Main Agent.
• Main Agent sends the pruned result to the XML
  writer (only if proof requested)
• XML writer returns the XML Proof.
• Main Agent returns Answer or Proof
• ANSWER(true false)
• PROOF(proof string)
• ERROR(error message)

29
Visual Agent
30
Command Line Agent

• Reads in a random way the questions from a
  configuration file
• Sends the question to the Main Agent with the
  order read
• The format of the questions is of the form
• predicate(proofanswer)
• The answers and proofs are stored at a files