Assumption-Based Truth Maintenance Systems

1. Assumption-Based Truth Maintenance Systems Meir Kalech

2. Outline • Last lecture: • Consistency-based diagnosis • GDE – general diagnosis engine • Conflict generation using ATMS • Candidate generation • Today’s lecture: • What is TMS • TMS architecture • Justification-based TMS • Assumption-based TMS

3. What is TMS? A Truth Maintenance System (TMS) is a Problem Solver module responsible for: • Enforcing logical relations among beliefs. • Generating explanations for conclusions. • Finding solutions to search problems • Supporting default reasoning. • Identifying causes for failure and recover from inconsistencies.

4. 1. Enforcement of logical relations • AI problem -> search. • Search utilizes assumptions. • Assumptions change. • Changing assumptions -> updating consequences of beliefs. • TMS: mechanism to maintain and update relations among beliefs.

5. 1. Enforcement of logical relations Example: If (cs-501) and (math-218) then (cs-570). If (cs-570) and (CIT) then (TMS). If (TMS) then (AI-experience). The following are relations among beliefs: (AI-experience) if (TMS). (TMS) if (cs-570), (CIT). (cs-570) if (cs-501), (math-218) • Beliefs are propositional variables • TMS is a mechanism for processing large collections of logical relations on propositional variables.

6. 2. Generation of explanations • Solving problems is what Problem Solvers do. • However, often solutions are not enough. • The PS is expected to provide an explanation • TMS uses cached inferences for that aim. • TMS is efficient: • Generating cached inferences once is more beneficial than • running inference rules that have generated these inferences more than once.

7. 2. Generation of explanations Example: Q: Shall I have an AI experience after completing the CIT program? A: Yes, because of the TMS course. Q: What do I need to take a TMS course? A: CS-570 and CIT. • There are different types of TMSs that provide different ways of explaining conclusions (JTMS vs ATMS). • In this example, explaining conclusions in terms of their immediate predecessors works much better.

8. 3. Finding solutions to search problems B A D C E • Color the nodes: red (1), green (2) yellow (3). • Adjacent nodes are of different colors. • The set of constraints describe this problem: A1 or A2 or A3 not (A1 and B1) not (A3 and C3) not (D2 and E2) B1 or B2 or B3 not (A2 and B2) not (B1 and D1) not (D3 and E3) C1 or C2 or C2 not (A3 and B3) not (B2 and D2) not (C1 and E1) D1 or D2 or D3 not (A1 and C1) not (B3 and D3) not (C2 and E2) E1 or E2 or E2 not (A2 and C2) not (D1 and E1) not (C3 and E3)

9. 3. Finding solutions to search problems To find a solution we can use search: A is red A is green A is yellow B is red B is yellow B is green C is green C is yellow C is red D is red D is yellow D is green E is yellow E is red E is green

10. 4. Default reasoning and TMS • PS must make conclusions based on incomplete information. • “Closed-World Assumption” (CWA) • X is true unless there is an evidence to the contrary. • CWA helps us limit the underlying search space. • The reasoning scheme that supports CWA is called “default (or non-monotonic) reasoning”.

11. 4. Default reasoning and TMS • Example: Consider the following knowledge base Bird(tom) and ¬Abnormal(tom)  Can_fly(tom) Penguin(tom)  Abnormal(tom) Ostrich(tom)  Abnormal(tom) Bird(tom) --------------------------------------------- Under the CWA, we assume ¬Abnormal(tom) and therefore we can derive: Can_fly(tom) • Non-monotonic TMS supports this type of reasoning.

12. 5. Identifying causes for failures and recovering from inconsistencies • Inconsistencies among beliefs in the KB are always possible: • wrong data (example: “Outside temperature is 320 degrees.”) • Impossible constraints (example: Big-house and Cheap-house and Nice-house). • TMS maintains help identify the reason for an inconsistency • “dependency-directed backtracking” allows the TMS to recover.

13. TMS applications • Constraint Satisfaction Problems (CSP) • Set of variables • Domain over each variable • Constraints between variables’ domain • Goal: find “solution”: assignments to the variables that satisfy the constraints • Scenario and Planning Problems • Find a path of state transitions lead from initial to final states. (games, strategies). • TMS – identifies of applicable rules.

14. CSP example Allocation problem • Two hosts: {h1,h2} (variables) • Three tasks: {t1,t2,t3} (domain) • Two constraints: • t1 before t2 on the same host • t1 could not be run on the same host of t3

15. CSP example t1-h1 t2-h1 t3-h1 t1-h2 t2-h2 t3-h3 t1-h1 t2-h1 t1-h1 t3-h1 t1-h2 t2-h2 t2-h2 t1-h2 t2-h1 t1-h1 t1-h2 t3-h2 t1-h1 t2-h1 t3-h1 t1-h2 t2-h2 t3-h1 t1-h1 t2-h1 t3-h2 t1-h2 t2-h2 t3-h2 … … 48 nodes 6 are solutions

16. Outline • Last lecture: • Consistency-based diagnosis • GDE – general diagnosis engine • Conflict generation using ATMS • Candidate generation • Today’s lecture: • What is TMS • TMS architecture • Justification-based TMS • Assumption-based TMS

17. Problem Solver Architecture The TMS / PS relationship is the following: Justifications, assumptions Problem Solver TMS Beliefs contradictions

18. How the TMS and the PS communicate? • The PS works with: • assertions (facts, beliefs, conclusions, hypotheses) • inference rules • procedures • Each one of these is assigned a TMS node. • Example: N1: (rule (student ?x) (assert (and (underpaid ?x) (overworked ?x)))) N2: (student Bob) • Given N1 and N2, the PS can infer N3: (and (underpaid Bob) (overworked Bob)) • PS threats nodes as logical formulas, • While TMS treats nodes as propositional variables.

19. TMS nodes • Different types of TMS support types of nodes: • Premise nodes. These are always true. • Contradiction nodes. These are always false. • Assumption nodes. PS believes no matter whether or not they are supported by the existing evidence. • Node has a label associated with it. The contents and the structure of the label depends on the type of TMS. • Other properties are node type (premise, assumption, etc.), node support (justifications, antecedents), node consequences, etc.

20. TMS justifications • If N3, is created by the PS, it reports to the TMS together with the fact that it follows from N1, N2. justification: (N3  N2 N1) • Here N3 is called the consequent, N1 and N2 are the antecedents of the justification. • Justifications record relations among beliefs or explaining consequents and identifying causes for inconsistencies. • The general format of justifications is the following: (<consequent> <antecedents>)

21. Propositional specification of a TMS • TMS nodes are propositional variables  • TMS justifications are propositional formulas N1 & N2 & … & Ni  Nj • Here N1, N2, …, Ni, Nj are positive literals, therefore this implication is a Horn formula. TMS can be viewed as a set of Horn formulas

22. Responsibilities of the PS: Adds assertions and justifications. Makes premises and assumptions. Retracts assumptions. Provides advise on handling contradictions PS / TMS interaction Responsibilities of the TMS: • Cashes beliefs and consequences and maintains labels. • Detects contradictions. • Performs belief revision. • Generates explanations.

23. Outline • Last lecture: • Consistency-based diagnosis • GDE – general diagnosis engine • Conflict generation using ATMS • Candidate generation • Today’s lecture: • What is TMS • TMS architecture • Justification-based TMS • Assumption-based TMS

24. Justification-based TMS Justifications are used for: • Belief update purpose, when belief state of a node changes. • Handle contradiction: • Justification is added to the dependency-directed backtracking system • Then search through the dependency network for the assumptions of the contradiction • Contradiction is removed.

25. Justification-based TMS • A justification contains inlist and outlist for a justified node to be believed: • inlist – a set of nodes that must be in • outlist – a set of nodes that must be out • Syntax: {(inlist),(outlist)} • Premises hold universally: empty in and out • Only one context includes the set of assumptions currently believed.

26. Justification-based TMS – Example Propositions: Justifications: A: Temperature>=25 {(),(B)} B: Temperature< 25 C: Not raining {(),(D)} D: Raining E: Day {(),(F)} F: Night PS concludes “nice weather” from A and C

27. Justification-based TMS – Example Propositions: Justifications: A: Temperature>=25 {(),(B)} B: Temperature< 25 C: Not raining {(),(D)} D: Raining E: Day {(),(F)} F: Night G: Nice weather {(A,C),()} New node in the JTMS

28. Justification-based TMS – Example Propositions: Justifications: A: Temperature>=25 {(),(B)} B: Temperature< 25 C: Not raining {(),(D)} D: Raining E: Day {(),(F)} F: Night G: Nice weather {(A,C),()} PS concludes “swim” from E and G

29. Justification-based TMS – Example Propositions: Justifications: A: Temperature>=25 {(),(B)} B: Temperature< 25 C: Not raining {(),(D)} D: Raining E: Day {(),(F)} F: Night G: Nice weather {(A,C),()} H: Swim {(E,G),()}

30. Justification-based TMS – Example Propositions: Justifications: A: Temperature>=25 {(),(B)} B: Temperature< 25 C: Not raining {(),(D)} D: Raining E: Day {(),(F)} F: Night G: Nice weather {(A,C),()} H: Swim {(E,G),()}

31. Justification-based TMS – Example Propositions: Justifications: A: Temperature>=25 {(),(B)} B: Temperature< 25 C: Not raining {(),(D)} D: Raining E: Day {(),(F)} F: Night G: Nice weather {(A,C),()} H: Swim {(E,G),()} I: Contradiction {(C),()} Dependency-directed backtracking system

32. Justification-based TMS – Example Propositions: Justifications: A: Temperature>=25 {(),(B)} B: Temperature< 25 C: Not raining {(),(D)} D: Raining E: Day {(),(F)} F: Night G: Nice weather {(A,C),()} H: Swim {(E,G),()} I: Contradiction {(C),()} X: Handle {(),()} //premise D: Raining {(X),()} Context: {(A,D,E), (B,C,F,G,H,I)}

33. Justification-based TMS – Example Propositions: Justifications: A: Temperature>=25 {(),(B)} B: Temperature< 25 C: Not raining {(),(D)} D: Raining E: Day {(),(F)} F: Night G: Nice weather {(A,C),()} H: Swim {(E,G),()} I: Contradiction {(C),()} X: Handle {(),()} //premise D: Raining {(X),()} J: Read {(D,E),()} K: Contradiction {(J),()} //becomes tired Dependency-directed backtracking system

34. Justification-based TMS – Example Propositions: Justifications: A: Temperature>=25 {(),(B)} B: Temperature< 25 C: Not raining {(),(D)} D: Raining E: Day {(),(F)} F: Night G: Nice weather {(A,C),()} H: Swim {(E,G),()} I: Contradiction {(C),()} X: Handle {(),()} //premise D: Raining {(X),()} J: Read {(D,E),()} K: Contradiction {(J),()} //becomes tired F: Night {(X),()} Context: {(A,D,F), (B,C,E,G,H,I,J,K)}

35. Justification-based TMS – Example Propositions: Justifications: A: Temperature>=25 {(),(B)} B: Temperature< 25 C: Not raining {(),(D)} D: Raining E: Day {(),(F)} F: Night G: Nice weather {(A,C),()} H: Swim {(E,G),()} I: Contradiction {(C),()} X: Handle {(),()} //premise D: Raining {(X),()} J: Read {(D,E),()} K: Contradiction {(J),()} //becomes tired F: Night {(X),()} L: Sleep {(F),()}

36. Outline • Last lecture: • Consistency-based diagnosis • GDE – general diagnosis engine • Conflict generation using ATMS • Candidate generation • Today’s lecture: • What is TMS • TMS architecture • Justification-based TMS • Assumption-based TMS

37. Assumption-based TMS: Motivation • Problem solvers need to explore multiple contexts at the same time, instead of a single one (the JTMS case) • Alternate diagnoses of a broken system • Different design choices • Competing theories to explain a set of data • Problem solvers need to compare contexts switching from one context to another. • In JTMS, this can be done by enabling and retracting assumptions. • In ATMS, alternative contexts are explicitly stored.

38. The idea behind ATMS • The assumptions underlying conclusions are important in problem-solving • Solutions can be described as sets of assumptions • States of the world can be represented by sets of assumptions • Identify sets of assumptions called here environments • Organize problem solver around manipulating environments • Facilitates reasoning with multiple hypotheses

39. Assumptions and Justifications • ATMS keeps and manipulates sets of assumptions rather than sets of beliefs • Three types of nodes: • Premise nodes. These are always true, but they are of no special interest for ATMS. • Assumption nodes. Once made, assumptions are never retracted. • Contradictions. These are defined by means of assumptions that originate them. Such sets of assumptions are called nogoods. • ATMS justifications are Horn formulas of the form: Jk: I1, I2, …, In  Ck, where I1, I2, …, In are the antecedents, and Ck is the consequent of justification Jk.

40. Basic ATMS terminology • ATMS answers queries about whether a node holds in a given set of beliefs. • Definition. A set of assumptions upon which a given node depends is called an environment. Example: {A,B,C} • Definition. A label is a set of environments. Example: {{A,B,C}, … ,{D,F}} That is, the label is the assumptions upon which the node ultimately depends – major difference from JTMS label, where labels are simple, :IN or :OUT. • Definition. An ATMS-node, Nk is a triplet <datum, label(status), justifications>

41. Basic ATMS terminology Definition. A node nholds in a given environment E, iff it can be derived from E given the set of justifications J: E,J ⊢ n An environment is inconsistent if false is derived: E,J ⊢⊥ Definition. Let E be a (consistent) environment, and N be a set of nodes derived from E. Then, E  N is called the context of E. • Definition. A characterizing environment is a minimal consistent environment from which a context can be derived. Each context is completely specified by its characterizing environment.

42. ATMS efficiency • ATMS is provided by a set of assumptions and justifications. • The task of ATMS is efficiently determines the contexts. • Incrementally updating only the changed contexts. • Data structure for context-consistency checking and node inclusion very fast.

43. Relations between environments Because environments are monotonic, set inclusion between environments implies logical subsumption of consequences. Example: E1 = {C} E2 = {C, D} E3 = {D, E} E1 subsumes E2 E2 is subsumed by E1 E1 neither subsumes or is subsumed by E3

44. How ATMS answers queries How ATMS answers queries about whether a node holds in a given environment? • Easiest way: associate with each node all of the environments • Better way: we can record only those environments which satisfy the following four properties: • Soundness: a node holds in any of the environments associated with it. • Consistency: no environment is a nogood. • Completeness: every consistent environment is either associated with it or with a superset of it. • Minimality: no environment is a subset of any other.

45. A B D F H G ATMS labels Example, dependency network: Is H believed? Yes, because its label is non-empty. Is H believed under {B, C, D, Z, X}? Yes, because {B, C, D}  {B, C, D, Z, X} Is H believed under {C, D}? No. {{A}} E {{A},{B,C,D}} {{B, C}} C {{C, D}}

46. Contradictions • Certain nodes can be declared as contradictions: • Every environment which allows a contradiction is inconsistent. • Inconsistent environments are called nogoods. • Example: {A,B} F {A,B,C} G {B,C}

47. Special labels in ATMS Case 1: Label = { } (empty label) This means that there is no knownconsistent environment in which the node is believed, i.e. either there is no path from assumptions to it, or all environments for it are inconsistent. Case 2: Label = {{}} (empty environment) This means that the node is believed in every consistent environment, i.e. the node is either a premise or can be derived strictly from premises.

48. A B I R C D G Label propagation L H K

49. B I R C D G Label propagation: enable A {{A}} A {{A}} L H K

50. {{A}, {B}} A {{A}, {B}} B I R C D G L H K Label propagation: enable B