Tableaux Systems

Tutorial at 1st School on Universal Logic

Montreux, 26-27 March 2005

Andreas Herzig

IRIT-CNRS
Toulouse
http://www.irit.fr/~Andreas.Herzig/

1
 What this tutorial is about
• in focus
– the tableaux method
– … for logics with possible worlds semantics
– … and combinations thereof
– … as a computerized proof system (LoTREC)
• not in focus:
– tableaus
– proof theory, sequent calculi (cf. course on LDS)
– completeness proofs
– efficiency issues

2
 Overview
• possible worlds semantics: quickstart
• tableaux systems: basic ideas
• tableaux systems: basic definitions
• tableaux for simple modal logics
• tableaux for transitive modal logics
• tableaux for intuitionistic logic
• tableaux for other nonclassical logics
• tableaux for modal logics with transitive closure and
other modal and description logics
• tableaux for 1st order logic
• some implemented tableaux theorem provers
3
 Possible worlds

• possible world ➔ p,q

valuation of classical
logic
~p,q

w ||- P iff ~p,~q

Vw(P) = 1, for P in Atoms
~p,q
w ||- AB iff
(w ||- A and w ||- B)

4
 Possible worlds models
• possible worlds model
= labeled graph
= transition system p,q

• node = possible world

– valuation of classical logic ~p,q
– not every valuation appears
(some logically possible ~p,~q
worlds are not actually
possible)
– Vw = Vu does not imply w = u ~p,q

• link = accessibility relation R

5
 Possible worlds models:
accessibility relations
• temporal
Rwu iff u is in the future of w
• alethic
Rwu iff u is possible, given the actual world w
• epistemic
Riwu iff u is possible for agent i, given the actual world w
• deontic
Rwu iff u is an ideal version of w
• dynamic
Rawu iff u is a possible result of the execution of program/action a in w
• comparative (preferential, …)
Rwu iff w is smaller than u
Rvwu iff w is smaller than u, given v

reading of R ➔ properties of R

6
 Possible worlds models:
properties of R
• monomodal • multimodal
– serial: forall w exists u Rwu – R1 included in R2
– reflexive – R1 = R2R3
– transitive – R2 = (R1)-1
– Euclidian (transitive closure)
– confluent (Church-Rosser) – R2 = (R1)*
– dense (transitive closure)
– … – R1 ° R2 = R 2 ° R1
– well-founded (not FO- – Church-Rosser
definable!) – …
– …

7
 Language:
modal operators
• express intensional concepts (belief, time,
action, obligation, …)
• non truth functional
• schema: op(a1,…,an), where op is the name of
the operator, and ai some argument
• generic form:
– []A = A is necessary (true in all possible worlds)
– <>A = A is possible
• in general: []A same as ~<>~A
– except in substructural logics (intuitionistic, …)

8
 Language:
modal operators
• temporal
– []A = henceforth A (true in all future time points)
– <>A = eventually A
• deontic
– []A = A is obligatory (true in all ideal worlds)
– <>A = A is permitted (~<>A = A is forbidden)
• epistemic
– []iA = i believes A (true in all worlds possible for i)
– <>iA = ..
• dynamic
– [a]A = A is true after (every possible way of) executing a
– <a>A = …
• conditional
– A => B = if A then B
proof of A can be transformed into proof of B (intuitionistic)
if A was true then B would be true (counterfactual)

9
 Interpreting the language:
truth conditions
• classical connectives
w ||- P iff Vw(P) = 1, for P in Atoms
w ||- AB iff (w ||- A and w ||- B)
• interpretation of non-classical connectives
– via accessibility relation R
• schema:
w ||- op(a1,…,an) iff Cond(op,a1,…,an,w,R)
• the basic modal operators:
w ||- []A iff forall u: Rwu implies u ||- A
w ||- <>A iff exists u: Rwu and u ||- A

10
 Examples of truth conditions
• multimodal operators
w ||- []iA iff forall u: Riwu implies u ||- A
w ||- <>iA iff …
• relation algebra operators
w ||- []-1A iff forall u: R-1wu implies u ||- A
w ||- []i  jA iff forall u: (RiRj)wu implies u ||- A
w ||- []*A iff forall u: R*wu implies u ||- A)
• non-normal operators
w ||- <>A iff forall Ri exists u: Riwu and u ||- A
w ||- []A iff exists Ri forall u …
11
 Examples of truth conditions:
temporal operators
R
R

• branching time operators

w ||- XA iff R in Paths(w): R(w) ||- A
(Paths(w) = the set of paths going through w)

12
 Examples of truth conditions:
temporal operators
R
R

• branching time operators

w ||- XA iff R in Paths(w): R(w) ||- A
(Paths(w) = the set of paths going through w)

w ||- <>A iff R in Paths(w) n Rn(w) ||- A

13
 Examples of truth conditions:
temporal operators

A A A B

• binary temporal operators

w ||- A Until B iff exists u: R*wu and u ||- B and
forall u’ (R*wu’ and R+vu’ implies u’ ||- A )

w ||- A Since B iff …

w ||- (A Until B) iff forall R in Paths(w) …

14
 Examples of truth conditions:
implications
• intuitionistic implication
w ||- A => B iff forall u: Rwu implies u ||- A → B
• conditional operator
w ||- A => B iff forall u: R[A]wu implies u ||- B
• relevant implication
w ||- A => B iff forall u,u’:
Rwuu’ implies (u ||- A implies u’ ||- B)

15
 Models
• model M = (W,R,V)
– W nonempty set (possible worlds)

– R: Ops → (WxW) (accessibility relation)

– V: W → (Atoms → {0,1}) (valuation)

• pointed model ((W,R,V),w)

– w in W (actual world)

• extension of A in M
[A]M = {w in W : w ||- A}

16
 Validity and satisfiability
• K = the set of all models (Kripke)

• A is valid in K iff [A]M = W for all M in K (|=K A)

examples: [](P v ~P)
[](PQ) → []P[]Q
[]P[]Q → [](PQ)

• A is satisfiable in K iff [A]M nonempy for some M in K

examples: P
P~[]P
P[]~P
[]P~[][]P

17
 Validity and satisfiability
in a class of models C
• Cls some subset of K

• A is valid in Cls iff [A]M = W for all M in Cls (|=Cls A)

examples: []P → P invalid in K
[]P → P valid in the class of reflexive models
<>P → <><>P valid in transitive models

• A is satisfiable in Cls iff [A]M nonempy for some M in Cls

examples: P~[]P satisfiable in K
P~[]P unsatisfiable in reflexive models

A is valid in Cls iff ~A is unsatisfiable in Cls

18
 Classes of models: examples
• {M: card(W) = 1}
|=Cls <>A → []A
• {M: card(W) = 2}
|=Cls <>(AB)  <>(~AB) → []B
• {M: card(W) finite}
…
• {M: R([]) reflexive} = KT
|=KT []A → A
• {M: R([]) transitive} = K4
|=K4 <><>A → <>A
• {M: R([]) equivalence relation} = S5
|=S5 A → []<>A

19
 Reasoning problems
• model checking
given A, M and w, do we have w ||- A?
• validity
given A and Cls, is A valid in Cls?
• satisfiability
given A and Cls, does there exist M in Cls and w in
M such that w ||- A?

How can we solve them automatically?

20
 Overview
• possible worlds semantics: quickstart
• tableaux systems: basic ideas
• tableaux systems: basic definitions
• tableaux for simple modal logics
• tableaux for transitive modal logics
• tableaux for intuitionistic logic
• tableaux for other nonclassical logics
• tableaux for modal logics with transitive closure and other modal and
description logics
• tableaux for 1st order logic
• some implemented tableaux theorem provers

21
 The basic idea
for classical logic [Beth]
• try to find M and w by applying the truth
conditions (“tableau rules”)
w ||- AB ➔ add w ||- A, and add w ||- B
w ||- A v B ➔ add either w ||- A, or add w ||- B (nondet.)
w ||- ~A ➔ “don’t add w ||- A” ???
– w ||- ~~A ➔ add w ||- A
– w ||- ~(A v B) ➔ add w ||- ~A, and add w ||- ~B
– w ||- ~(AB) ➔ add either w ||- ~A, or add w ||- ~B
• apply while possible (“downwards saturation")
• is this a model?
NO if both w ||- P and w ||- ~P (“tableau is closed”)
ELSE: for every w, if w ||- P put Vw(P) = 1, else put Vw(P) = 0

22
 The basic idea:
example for classical logic
A = P~(PQ)

• applying truth conditions:

1. w ||- P~(PQ)
2. w ||- P~(PQ), w ||- P, w ||- ~(PQ)
3. w ||- P~(PQ), w ||- P, w ||- ~(PQ), w ||- ~P (nondet.)
• no more truth condition applies
• can’t be a model:
both w ||- P and w ||- ~P
• backtrack on nondeterministic choices

23
 The basic idea:
example for classical logic (ctd.)
• 1st downward saturated
graph for
A = P~(PQ)
➔ not a model
(contains P and ~P!)

24
 The basic idea:
example for classical logic (ctd.)
• 1st downward saturated
set for
A = P  ~(PQ)
➔ not a model
(contains P and ~P!)

• 2nd downward saturated

set for
A = P  ~(PQ)
➔ is a model of A

25
 The basic idea
for modal logics
• apply truth conditions = build a graph
– create nodes
– add links between nodes
– add formulas to nodes
• the basic cases
w ||- []A ➔ forall u such that Rwu, add u ||- A
w ||- <>A ➔ add some new u, add Rwu, add u ||- A
w ||- ~[]A ➔ add some new u, add Rwu, add u ||- ~A
w ||- ~<>A ➔ …
• “downwards saturated graph”: is this a model?

26
 The basic idea:
example for modal logic
A = P  ~[]P

• applying tableau rules:

1. w ||- P~[]P
2. w ||- P~[]P, w ||- P, w ||- ~[]P
3. w ||- P~[]P, w ||- P, w ||- ~[]P, Rwu, u ||- ~P
no more tableau rule applies
➔ never both w ||- A and w ||- ~A (“open tableau”)
• model can be built: M = (W,R,V)
set of worlds W: W = {w,u}
accessibility relation R: R[]wu
valuation V: Vw(P) = 1, Vu(P) = 0

27
 The basic idea:
example for modal logic (ctd.)
• premodel for
A = P  ~[]P

➔ not closed
➔ is a model of A

28
 A remark on tableaux
and truth tables
• Tableaux are a more convenient presentation of
the familiar truth table analysis” [Beth]
• “Tableaux are more efficient than truth tables.”
[folklore]
• … not exactly [d’Agostino]:
(P1 v P2 v P3)  (P1 v P2 v ~P3)  (P1 v ~P2 v P3)  …
there are formulas with n atoms of length O(2n)
➔ truth tables have 2n rows
➔ at least n! closed tableaux, and n! grows faster than 2n

29
 Historical remarks
• the early days (1950-80): handwritten proofs
– Beth, Gentzen
– relation to sequent calculus
“tableau proof = sequent proof backwards”
– Kripke: explicit accessibility relation
– Smullyan, Fitting: uniform notation
• today: mechanized systems
– fast provers exist
FaCT [Horrocks]
K-SAT [Giunchiglia&Sebastiani]
importance of strategies
– applications exist: BDI logics, description logics

30
 Overview
• possible worlds semantics: quickstart
• tableaux systems: basic ideas
• tableaux systems: basic definitions
• tableaux for simple modal logics
• tableaux for transitive modal logics
• tableaux for intuitionistic logic
• tableaux for other nonclassical logics
• tableaux for modal logics with transitive closure and other modal and
description logics
• tableaux for 1st order logic
• some implemented tableaux theorem provers

31
 Informal definition of tableau rules

• Tableau rules expand directed graphs by

– adding formulas
– adding nodes
– adding links
– duplicating the graph
• rule(G) = {G1,…,Gn}

32
 Informal definition of tableau rules

• Tableau rules expand directed graphs by

– adding formulas
– adding nodes
– adding links
– duplicating the graph
• rule(G) = {G1,…,Gn}

• application of a rule to G =
application to every formula in every node of G.
• rule({G1,…,Gn}) = rule(G1)…rule(Gn)
33
 Tableau rules: syntax
• general form: • example conditions:
rule ruleName if hasElement node formula
if cond1 if isLinked node1 node2 R
… ... (more to come)
if condn
do action1 • example actions:
… do stop
do actionk do addElement node formula
do newNode node
do link node1 node2 R
do duplicate node1 […]
... (more to come)

34
 Example: tableau rules
for classical logic

the
LoTREC
tableau
prover

35
 Example: tableau rules
for classical logic
declaration of connectors:
negation and conjunction only

36
 Example: tableau rules
for classical logic

rule Stop:
if there is an explicit contradiction
then stop exploring the tableau

37
 Example: tableau rules
for classical logic

rule NotNot:
replaces ~~A by A

38
 Example: tableau rules
for classical logic

rule And:
if A & B is in a node
then add A and B to node

39
 Example: tableau rules
for classical logic

rule NotAnd:
if ~(A&B) is in a node
then duplicate tableau,
add ~A to the first tableau
add ~B to the second tableau

40
 Definition of strategies
• A strategy defines some order of
application of the tableau rules:
firstrule rule1 … rulen end
“apply first applicable rule and stop”
allrules rule1 … rulen end
“apply all applicable rules in order”
repeat strategy end
“repeat until no rule applicable”
• Strategy stops if no rule is applicable.
41
 Strategy
for classical logic
strategy CPLStrategy
repeat allRules
Stop
NotNot
And
NotAnd
end end
end

➔ “fair strategy”
42
 Strategy for classical logic:
example
CPLStrategy(P&~(P&Q))

43
 Strategy for classical logic:
example (ctd.)

CPLStrategy(P&~(P&Q)) =

{ T1 , T2 }

44
 Definition of tableaux
The set of tableaux for A with strategy S is
the set of graphs
obtained by applying the strategy S
to an initial single-node graph
whose root contains only A.

• notation: S(A)

– Remark
our tableau = “tableau branch” in the literature
(sounds odd to call a graph a branch)

45
 Tableaux: open or closed?
• A node is closed iff it contains FALSE.
• A tableau is closed iff it has a closed node.
• A set of tableaux is closed
iff all its elements are.

An open tableau is a premodel:

➔ build a model

46
 Formal properties
to be proved for each strategy:

• Termination
For every A, S(A) terminates.
• Soundness
If S(A) is closed then A is unsatisfiable.
• Completeness
If S(A) is open then A is satisfiable.
47
 Termination
• For every A, CPLTableaux(A) terminates.

• Proof:
– Every tableau rule only adds strict
subformulas.
– This can only be done a finite number of
times, then the strategy stops.

48
 Soundness
• If CPLTableaux(A) is closed
then A is unsatisfiable.

• Proof:
– Every tableau rule is “guaranteed” by the truth
conditions:
If G is CPL-satisfiable
then there is Gi in rule(G) that is CPL-satisfiable
– Hence if every graph is closed
then the original A cannot be satisfiable.

49
 Completeness
• If CPLTableaux(A) is open then A is satisfiable.
• Proof:
– Take some open tableau G in CPLTableaux(A).

50
 Completeness
• If CPLTableaux(A) is open then A is satisfiable.
• Proof:
– Take some open tableau G in CPLTableaux(A).
– G is a downwards closed set (“Hintikka set”):
if ~~A in node then A in node
if A&B in node then A in node and B in node
if ~(A&B) in node then ~A in node or ~B in node
(because allRules strategy is fair: every rule eventually applies)

51
 Completeness
• If CPLTableaux(A) is open then A is satisfiable.
• Proof:
– Take some open tableau G in CPLTableaux(A).
– G is a downwards closed set (“Hintikka set”):
if ~~A in node then A in node
if A&B in node then A in node and B in node
if ~(A&B) in node then ~A in node or ~B in node
(because allRules strategy is fair: every rule eventually applies)
– Build a CPL model from G:
Vnode(P) = 1 iff P appears in node

52
 Completeness
• If CPLTableaux(A) is open then A is satisfiable.
• Proof:
– Take some open tableau G in CPLTableaux(A).
– G is a downwards closed set (“Hintikka set”):
if ~~A in node then A in node
if A&B in node then A in node and B in node
if ~(A&B) in node then ~A in node or ~B in node
(because allRules strategy is fair: every rule eventually applies)
– Build a CPL model from G:
Vnode(P) = 1 iff P appears in node
– Prove by induction on the form of A:
for every A in node, Vnode(A) = 1
(“fundamental lemma”)

53
 In general …
• soundness proof … easy
• termination proof … difficult
• completeness proof … very difficult

54
 In general …
• soundness proof: easy
• termination proof: difficult
• completeness proof: very difficult

• … but soundness + termination of strategy is

practically sufficient:
1. apply strategy to A
2. take an open tableau and build pointed model (M,w)
3. check if M in model class
4. check if M,w ||- A

55
 Overview
• possible worlds semantics: quickstart
• tableaux systems: basic ideas
• tableaux systems: basic definitions
• tableaux for simple modal logics
• tableaux for transitive modal logics
• tableaux for intuitionistic logic
• tableaux for other nonclassical logics
• tableaux for modal logics with transitive closure and
other modal and description logics
• tableaux for 1st order logic
• some implemented tableaux theorem provers
56
 The basic modal logic K
• the basic modal operators:
w ||- []A iff forall u: Rwu implies u ||- A
w ||- <>A iff exists u: Rwu and u ||- A

57
 Tableau rules for K
connectors: not, and, nec

[some rules for classical logic…]

58
 Tableau rules for K
connectors: not, and, nec

[some rules for classical logic…]

createSuccessor:
if not nec A is in node0
then create new node node1
link it to node0
add not A to node1
end

59
 Tableau rules for K
connectors: not, and, nec

[some rules for classical logic…]

propagateNec:
if nec A is in node0
node0 is linkednode1 R
then add node1 A
end

60
 Tableaux for K
• … plus rules for the definable connectives

• KStrategy(<>P & <>Q & [](R v <>S))

61
 Modal logic KT
• accessibility relation is reflexive
• idea: integrate this into truth condition
– w ||- []A iff w ||- A and forall u: Rwu implies u ||- A

62
 Tableaux
for modal logic KT
[connectors as for K…]

[rules as for K…]

63
 Tableaux
for modal logic KT
[connectors as for K…]

[rules as for K…]

plus: “when []A is in a node

then add A to it”

• KTStrategy(P & [][]~P)

64
 Tableaux
for modal logic S5
accessibility relation is
equivalence relation

can be supposed to be
a single equivalence
class

optimized tableau rules

…

65
 Overview
• possible worlds semantics: quickstart
• tableaux systems: basic ideas
• tableaux systems: basic definitions
• tableaux for simple modal logics
• tableaux for transitive modal logics
• tableaux for intuitionistic logic
• tableaux for other nonclassical logics
• tableaux for modal logics with transitive closure and
other modal and description logics
• tableaux for 1st order logic
• some implemented tableaux theorem provers
66
 Tableau rules for S4
accessibility relation is reflexive and transitive

tableau rules for S4:

• [connectors as for KT…]
• [rules as for KT…]
• … and take into account transitivity:
“when []A is in a node
then add []A to all children”

67
 Tableau rules for S4
accessibility relation is reflexive and transitive

tableau rules for S4:

• [connectors as for KT…]
• [rules as for KT…]
• … and take into account transitivity:
“if []A is in a node
then add []A to all children”

problem: find a terminating strategy

68
 Tableau rules for S4
• Example: w ||- []~[]P
– add w ||- ~[]P (by rule for reflexivity)

69
 Tableau rules for S4
• Example: w ||- []~[]P
– add w ||- ~[]P (by rule for reflexivity)
– create u, add Rwu, add u ||- ~P
(by createSuccessor)

70
 Tableau rules for S4
• Example: w ||- []~[]P
– add w ||- ~[]P (by rule for reflexivity)
– create u, add Rwu, add u ||- ~P
(by createSuccessor)
– add u ||- []~[]P (by rule for transitivity)

71
 Tableau rules for S4
• Example: w ||- []~[]P
– add w ||- ~[]P (by rule for reflexivity)
– create u, add Rwu, add u ||- ~P
(by createSuccessor)
– add u ||- []~[]P (by rule for transitivity)
– add u ||- ~[]P (by rule for reflexivity)

72
 Tableau rules for S4
• Example: w ||- []~[]P
– add w ||- ~[]P (by rule for reflexivity)
– create u, add Rwu, add u ||- ~P
(by createSuccessor)
– add u ||- []~[]P (by rule for transitivity)
– add u ||- ~[]P (by rule for reflexivity)
– create u’
–…

73
 Tableau rules for S4
• Example: w ||- []~[]P
– add w ||- ~[]P (by rule for reflexivity)
– create u, add Rwu, add u ||- ~P
(by createSuccessor)
– add u ||- []~[]P (by rule for transitivity)
– add u ||- ~[]P (by rule for reflexivity)
– create u’
–…
put a looptest into the rules!

74
 Tableau rules for S4 (ctd.)
principle:
• if a node is included in
an ancestor
then mark it.

75
 Tableau rules for S4 (ctd.)
principle:
• if a node is included in
an ancestor
then mark it.

• if a node is marked
then block the
createSuccessor rule

• S4Strategy([]~[]P)

76
 S4Strategy
([]<>[] (P v Q) & []<>~P & <>[]~Q)

77
 Overview
• possible worlds semantics: quickstart
• tableaux systems: basic ideas
• tableaux systems: basic definitions
• tableaux for simple modal logics
• tableaux for transitive modal logics
• tableaux for intuitionistic logic
• tableaux for other nonclassical logics
• tableaux for modal logics with transitive closure and
other modal and description logics
• tableaux for 1st order logic
• some implemented tableaux theorem provers
78
 Intuitionistic logic
• no modal operators, but different semantics for
implication and negation
• aim: invalidate
(~P=>FALSE) => P ex falso quodlibet
P v ~P tertio non datur
(~Q => ~P) => (P => Q) contraposition
• R is reflexive, transitive and hereditary:
if Rwu and Vw(P) = 1 then Vu(P) = 1
• similar to S4
• truth condition
w ||- A=>B iff forall u: Rwu implies u ||- A→B

79
 Tableaux rules for
intuitionistic logic
• follow translation from LJ to S4:
P’ = []P (inheritance)
(A=>B)’ = [](A’ → B’)
(~A)’ = []~(A’)
• tableaux similar to S4
• signed formulas
T(P) “P is true”
F(P) “P is false”
F(P) ≠ ~P

80
 Tableaux rules for
intuitionistic logic
• create successor
make A=>B false in w:
create u, add link Rwu,
make A false in u,
make B true in u

81
 Tableaux rules for
intuitionistic logic
• create successor
make A=>B false in w:
create u, add link Rwu,
make A false in u,
make B true in u

• inheritance
if w ||- P and Rwu
then add u ||- P

82
 Tableaux rules for
intuitionistic logic: ~~P=>P
LJStrategy(((P=>False)=>False)=>P) ➔ 4 tableaux, 1 open

83
 Overview
• possible worlds semantics: quickstart
• tableaux systems: basic ideas
• tableaux systems: basic definitions
• tableaux for simple modal logics
• tableaux for transitive modal logics
• tableaux for intuitionistic logic
• tableaux for other nonclassical logics
• tableaux for modal logics with transitive closure and
other modal and description logics
• tableaux for 1st order logic
• some implemented tableaux theorem provers
84
 Relevant logics
• …

85
 Paraconsistent logics
• …

86
 Overview
• possible worlds semantics: quickstart
• tableaux systems: basic ideas
• tableaux systems: basic definitions
• tableaux for simple modal logics
• tableaux for transitive modal logics
• tableaux for intuitionistic logic
• tableaux for other nonclassical logics
• tableaux for modal logics with transitive closure and
other modal and description logics
• tableaux for 1st order logic
• some implemented tableaux theorem provers
87
 Linear Temporal Logic
• two modal operators:
[] = always
X = next
• R(X) is serial and deterministic
• R([]) = R(X))*
R([]) linear order
• mix axioms:
[]A  AX[]A
<>A  A v X<>A
• induction axiom:
A[](A→XA) → []A
• decidable, EXPTIME complete
88
 Tableau rules for
Linear Temporal Logic
how take induction into account?

• solution: don’t care, and only apply the mix axioms:

rewrite []A to A  X[]A
rewrite <>A to A v X<>A
• only create successors for X, never for <>
• termination: use the looptest from transitive modal logics
– nodes only contain subformulas of orig. formula
– looptest succeeds at most at polynomial depth

89
 Tableau rules for
Linear Temporal Logic: example
• Example: w ||- []P
add w ||- PX[]P (by mix axioms)
add w ||- P, w ||- X[]P
create u, add RXwu, add u ||- []P
(by propagation rule for X)
add u ||- PX[]P (by mix axioms)
add u ||- P, u ||- X[]P
w contains u: mark u “contained”

90
 Tableau rules for
Linear Temporal Logic (ctd.)

~P ~P ~P ~P
…

• may result in ‘nonstandard’ models of <>P

➔ “P never fulfilled”
➔ check if all <> are fulfilled!

91
 Tableau rules for
Linear Temporal Logic: example
• Example: LTLStrategy(<>P)
w ||- <>P

92
 Tableau rules for
Linear Temporal Logic
• Example: LTLStrategy(<>P)
w ||- <>P
w ||- P v X<>P (by mix)

93
 Tableau rules for
Linear Temporal Logic
• Example: LTLStrategy(<>P)
w ||- <>P
w ||- P v X<>P (by mix)

w ||- <>P, w ||- Pw’ ||- <>P, w’ ||- X<>P

(nothing applies)
.

94
 Tableau rules for
Linear Temporal Logic
• Example: LTLStrategy(<>P)
w ||- <>P
w ||- P v X<>P (by mix)

w ||- <>P, w ||- Pw’ ||- <>P, w’ ||- X<>P

(nothing applies) RXw’u’, u’ ||- <>P
.

95
 Tableau rules for
Linear Temporal Logic
• Example: LTLStrategy(<>P)
w ||- <>P
w ||- P v X<>P (by mix)

w ||- <>P, w ||- Pw’ ||- <>P, w’ ||- X<>P

(nothing applies) RXw’u’, u’ ||- <>P
u’ ||- P v X<>P (by mix)

96
 Tableau rules for
Linear Temporal Logic
• Example: LTLStrategy(<>P)
w ||- <>P
w ||- P v X<>P (by mix)

w ||- <>P, w ||- Pw’ ||- <>P, w’ ||- X<>P

(nothing applies) RXw’u’, u’ ||- <>P
u’ ||- P v X<>P (by mix)

u’ ||- P u’’ ||- X<>P

97
 Tableau rules for
Linear Temporal Logic
• Example: LTLStrategy(<>P)
w ||- <>P
w ||- P v X<>P (by mix)

w ||- <>P, w ||- Pw’ ||- <>P, w’ ||- X<>P

(nothing applies) RXw’u’, u’ ||- <>P
u’ ||- P v X<>P (by mix)

u’ ||- P u’’ ||- X<>P

(nothing applies) contained in w’

98
 Tableau rules for
Linear Temporal Logic
• Example: LTLStrategy(<>P)
w ||- <>P
w ||- P v X<>P (by mix)

w ||- <>P, w ||- Pw’ ||- <>P, w’ ||- X<>P

(nothing applies) RXw’u’, u’ ||- <>P
u’ ||- P v X<>P (by mix)

u’ ||- P u’’ ||- X<>P

(nothing applies) u’’ contained in w’
<>P not fulfilled

99
 Propositional dynamic logic (PDL)
• two kinds of expressions
– formulas:
A ::= P | ~A | AB | [p]A
– programs:
p ::= a | p1;p2 | p1p2 | p* | A?
• in the models: R interprets programs
R(p1;p2) = R(p1);R(p2)
R(p1p2) = R(p1)R(p2)
R(p*) = (R(p))*
R(A?) = {<w,w> : w ||- A}
100
 Tableaux for PDL
• similar to LTL:
– expand [p*]A to A  [p][p*]A
– don’t apply createSuccessor to formulas ~[p*]A
– mark nodes that are included in some ancestor
– don’t apply createSuccessor to formulas ~[p]A if node
is marked
– expand the other program expressions:
[p1;p2]A  [p1][p2]A
[p1p2]A  [p1]A  [p2]A
[A?]B  A→B

101
 Description logics
• “roles” and “concepts”
– more expressive than classical propositional logic
– less expressive than 1st order logic
• focus on decidable logics
• applications:
– databases
– software engineering
– web-based information systems
description of medical terminology
– ontology of the semantic web
standards: DAML+OIL, OWL
– description of web services
WSDL, OWL-S

102
 Description logics:
concepts and roles
• roles = binary relations
hasChild
hasHusband
• concepts = unary relations = properties
Person
Female
Parent ∩ Female
Father U Mother
~Parent
hasChild.Female “individuals having a female child”
hasChild.Female “…”
>1 hasChild.T “individuals having more than 1 child”
• set of concepts ➔ “assertion box” (ABox)
103
 Description logics:
TBoxes
• set of relations between concepts and
roles
➔ “terminological box” (TBox)
– restricted to concept abbreviations
(sometimes: fixpoint definitions)
Mother = Person ∩ Female
– are expanded away ➔ TBox = 

104
 Description logics:
reasoning tasks
• satisfiability of a concept C
• subsumption of C1 by C2
same as: C1∩~ C2 unsatisfiable
• equivalence of C1 by C2
same as: C1 subsumes C2 and C1 subsumes C2
• disjointness of C1 and C2
⊥ subsumes C1∩C2

➔ all reasoning tasks reduce

to concept satisfiability
105
 Description logics
• translation of concepts into modal logics
hasChild.Female = <hasChild>Female
hasChild.Female = [hasChild.Female]
Parent ∩ Female = Parent  Female
Father U Mother = Father v Mother
<2 hasChild.T = [hasChild]2 T
≥2 hasChild.T = <hasChild>2 T
…modal logics with number restrictions
[Fattorosi&Barnaba, van der Hoek]

106
 Description logics
• description logic ALC:
~C
C1 ∩ C2
C1 U C2
R.C
R.C
= multimodal K
• description logic ALCreg =
ALC + regular expressions on roles
= PDL
• all description logic reasoning tasks reduce
to satisfiability checking in modal logics
• tableaux used as optimal decision procedures

107
Logics of action and knowledge
• 2 modal operators
Knwi A “agent i knows that A”
[a] A “after execution of action a, A holds”
• “product logics”:
RKnwi°Ra = Ra°RKnwi (permutation)
if wRKnwiu and wRav then exists t such that uRat and vRKnwit
(confluence)
• axiomatically:
Knwi[a]A  [a]KnwiA
<a>KnwiA → Knwi<a>A

tableaux: …
➔ problem: combination with transitivity

108
 Belief-Desire-Intention logics
• [Bratman, Rao&Georgeff]
• 3 modal operators
Beli A “agent i believes that A”
Desirei A “agent i desires that A”
Intendi A “agent i intends that A”
• plus branching time logic

109
 Modal logics with density
• accessibility relation is dense
if Rwu then exists v : Rwv and Rvu

• …

110
 Non-normal modal logics
• no accessibility relation, but neighborhood
functions: N: W → 22W
w ||- []A iff exists U in N(w) forall u in U: u ||- A
non-normal modal logic EM
• can be represented by a set of relations
w ||- []A iff exists Ri forall u (Riwu implies u ||- A)
• logic EM: “non-normal”
not valid: []P[]Q → [](PQ)
but valid: [](PQ) → []P[]Q
111
 Tableau rules for EM
• …

112
 Overview
• possible worlds semantics: quickstart
• tableaux systems: basic ideas
• tableaux systems: basic definitions
• tableaux for simple modal logics
• tableaux for transitive modal logics
• tableaux for intuitionistic logic
• tableaux for other nonclassical logics
• tableaux for modal logics with transitive closure and
other modal and description logics
• tableaux for 1st order logic
• some implemented tableaux theorem provers
113
 1st order logic
• How should we handle the quantifiers?
x p(x)  ~p(a) is unsatisfiable
x p(x)  x ~p(x) is unsatisfiable
• naïve implementation [Beth, Smullyan]:
if hasElement node0 forall x A(x)
do createTerm t (doesn’t exist in LoTREC yet)
do add node0 A(t)

if hasElement node exists x A(x)

do createNewConstant c
do add node A(c)

➔problem: loops for satisfiable formulas

114
 Herbrand Tableaux for
1st order logic
• 1st solution: restrict instantiation to Herbrand universe
if hasElement node0 forall x A(x)
do createHerbrandTerm t (doesn’t exist in LoTREC yet)
do add node0 A(t)
• ex.: x p(x,x)  xy ~p(x,y)) satisfiable
1. x p(x,x)
2. xy ~p(x,y)
3. y ~p(a,y) (2), new constant
4. ~p(a,a) (3), only Herbrand term
5. p(b,b) (1), new constant
6. ~p(a,b) (3), Herbrand term
no further instantiation of (3) is possible
• decision procedure for formulas without positive …

115
 Herbrand Tableaux for
1st order logic
• counterexample: xy p(x,y) satisfiable
1. xy p(x,y)
2. y p(a,y) (1), Herbrand term
3. p(a,b) (2), new constant
4. y p(b,y) (1), Herbrand term
5. p(b,c) (4), new constant
6. …

➔ loops
116
 Free-variable tableaux
with unification
• 2nd solution: don’t instantiate at all
– work with free variables
– runtime skolemization of existential quantifiers
– term unification
• ex.: xy p(x,y)  xy ~p(x,y)) satisfiable
1. xy p(x,y)
2. xy ~p(x,y)
3. y p(x1,y) from (1), replace x by free x1
4. y ~p(x2,y) from (2), replace x by free x2
5. p(x1,f(x1)) from (3), Skolem function f(x1)
6. ~p(x2,g(x2)) from (4), Skolem function g(x2)
stops: (5) and (6) don’t unify

• … but does not terminate in all cases (sure)

else 1st order logic would be decidable

117
 Overview
• possible worlds semantics: quickstart
• tableaux systems: basic ideas
• tableaux systems: basic definitions
• tableaux for simple modal logics
• tableaux for transitive modal logics
• tableaux for intuitionistic logic
• tableaux for other nonclassical logics
• tableaux for modal logics with transitive closure and
other modal and description logics
• tableaux for 1st order logic
• some implemented tableaux theorem provers
118
 LoTREC
• IRIT-CNRS Toulouse (Sahade, Gasquet,
Herzig); accessible through www
• general theorem prover
• explicit accessibility relations
• easy to implement logics with symmetric
accessibility relations etc.
– back-and-forth rules
• inefficient
119
 TableauxWorkBench (TWB)
• Australian National U. (Abate, Goré)
• general theorem prover
• close to Gentzen sequents
• accessibility relations remain implicit
• hard to implement logics with symmetric
accessibility relations
– temporal logic with future and past
– converse of programs
120
 LogicWorkBench (LWB)
• U. Bern (Jäger, Heuerding); accessible
through www
• efficient algorithms for all the basic modal
and temporal logics
• hard to implement a new logic

121
 FaCT
• U. Manchester (Horrocks); open source
• fast decision procedure for description
logics with inverse roles and qualified
number restrictions
= multimodal K + converse + number restrictions
• optimized backtracking: “backjumping”

122
 KSAT
• U. Trento (Giunchiglia, Sebastiani)
• combines tableaux method with fast SAT solvers
for classical propositional logic
– call a SAT solver, where subformulas []A, <>B are
viewed as atomic
– SAT solver returns a tentative valuation
– use modal tableau rules to generate children
if inconsistent then there is no model
else iterate
• very efficient
• exists for all basic modal logics
123
 KSAT (ctd.)
• KSAT([](P&Q) & <>~P)
– call SAT with set of clauses {[](P&Q), <>~P}
– SAT returns:
V([](P&Q)) = 1
V(<>~P) = 1
– apply createOneSuccessor and propagateNec:
w ||- [](P&Q), w ||- <>~P, Rwu, u ||- ~P, u ||- P&Q
– call SAT with set of clauses {P,Q,~P}
– SAT returns:
set of clauses unsatisfiable
– [](P&Q) & <>~P is unsatisfiable in K

124
 Conclusion
• search for models = exploit the truth
conditions
• tableaux work both ways:
– finding a model
– refuting
• termination = decidability
• tableaux as optimal decision procedures
➔ description logics
125
 Thanks to…
• Mohamad Sahade
• Olivier Gasquet
• Luis Fariñas del Cerro
• Dominique Longin
• Tiago Santos de Lima
• Fabrice Evrard
• Carole Adam
• Nicolas Troquard
• Benoit Gaudou
• Ivan Varzinczak
• Bilal Saïd
• Dominique Ziegelmayer
• … and the other members of the LILaC group

126