Algorithm for generating resolvents

Let_{hΦ, αi be an argument, where α and the formulae from Φ and are clauses. In chapter 4 it was} proved that there is ana _{∈ Disjuncts(α) such that (N, A, f) is a support tree for ∆, α and a, such} thatΦ = {f(x) | x ∈ N} \ {a}. In previous paragraphs of this chapter it was described how using the negation of each of the clauses from SResolvents(Φ) as claims for arguments can be useful for generating canonical undercuts for_{hΦ, αi. This section introduces an algorithm that generates SResolvents(Φ)} based on the structure of the suppport tree(N, A, f) that corresponds to Φ.

Apart from providing a minimal and consistent proof for a claimα, a support tree can also be used to generate SResolvents(Φ) efficiently. The way the support tree is built helps minimizing the number of disjuncts of the resolvents produced when the order in which the resolution of clauses happens is indicated by a post-order traversal of(N, A, f).

Given for an argument_{hΦ, αi a support tree (N, A, f) for ∆, α and a that corresponds to Φ, i.e.} Φ = {f(x) | x ∈ N} \ {a}, algorithm GetSResolvents((N, A, f)) returns the set SResolvents(Φ). Using function ResolveSubtree(y) the algorithm assigns a set of clauses to each node y, that repre- sents the set of strong resolvents produced by_{{f(x) | x ∈ Subtree(y)}. Initially, before the traversal} takes place, for each non-root nodey from N , ResolveSubtree(y) is initialized to be equal to _{f(y)} and for the root node it is initialized to be equal to the empty set (since a _{6∈ Φ and a will not be} considered when applying resolution in order to produce the set SResolvents(Φ)). Each node is vi- sited after all its children have been visited. Every time a child x of node y is visited, the value of Resolvents(ResolveSubtree(x) ∪ ResolveSubtree(y)) is assigned to ResolveSubtree(y). Every time set ResolveSubtree(y) is updated, the clauses for which there is a stronger clause in ResolveSubtree(y) are removed using function RemoveSubsumed. In this way, the number of resolvents produced at each step is controlled and the comparison for subsumed clauses is focused on each node and happens locally. Hence, for each node y that has been visited and processed during the traversal, ResolveSubtree(y) gives the set of strong resolvents of the set of clauses that represent its subtree. When the root node root is reached during the traversal, the algorithm outputs ResolveSubtree(root) which is the set SResolvents({f(x) | x ∈ N} \ {a}) = SResolvents(Φ). In order to traverse the tree, the algorithm uses functions FirstChild(x), Parent(x), and NextSibling(x) which, given a node x, return respectively the first child ofx, the parent of x and the next sibling of x in (N, A, f ). Boolean function Visited(x) indicates whether nodex has been visited so far during the traversal.

In the case where (N, A, f) is a support tree that has been retrieved while looking for a ca- nonical undercut _{hΨ, i for some argument that has a support Ψ}0, then apart from clauses from Ψ, (N, A, f) can also contain clauses from SResolvents(Ψ0_{). As explained in section 5.1.2, in order to}

find a canonical undercut for an argument with supportΨ0we look for arguments_{hΨ ∪ Γ, ¬ρi for all the} ρ_{∈ SResolvents(Ψ}0_{) from (∆ \ ∆}0_{) ∪ SResolvents(Ψ}0_{) where ∆}0_{is the set of clauses that are subsumed}

by some clauses from SResolvents(Ψ0_{), Ψ}0

⊂ ∆ and Γ ⊂ SResolvents(Ψ0_{). In this case, the presupport}

tree contains the clauses ofΨ ∪Γ, where Γ may or may not be equal to the empty set. Then, the traversal would produce SResolvents(Ψ ∪ Γ) rather than SResolvents(Ψ). In order to avoid this, the nodes z of

5.3. Algorithms 94 (N, A, f) for which f(z) ∈ Γ, have the value for ResolveSubtree(z) initialized to be the empty set. This way, no clauses fromΓ are involved in the resolvents produced by the traversal of (N, A, f). For the same reason, in all support trees the root node has its value for ResolveSubtree initialized to be equal to the empty set since it does not represent a clause from the set for which the set of strong resolvents has to be generated.

Algorithm 5.1 GetSResolvents((N, A, f))

1: x = root

2: whilex_{6= null do}

3: if FirstChild(x) 6= null & Visited(x) == false then

4: Visited(x) = true

5: x = FirstChild(x)

6: else

7: y = Parent(x)

8: ResolveSubtree(y) = Resolvents(ResolveSubtree(y) ∪ ResolveSubtree(x))

9: ResolveSubtree(y) = RemoveSubsumed(ResolveSubtree(y)) 10: if NextSibling(x) 6= null then

11: x = NextSibling(x) 12: else 13: x = Parent(x) 14: end if 15: end if 16: ifx == root then 17: return ResolveSubtree(x) 18: end if 19: end while

The following example illustrates how algorithm GetSResolvents works on one of the support trees of example 5.2.1. The clause representation of each nodex is used to denote x, and each corresponding line of the algorithm operation is given on the right hand side of each step. The tree on which the algorithm is applied represents the search for an argument_{hΦ, αi for a clause α and not the search for} a canonical undercut, hence the set of non-root nodes from(N, A, f) is equal to Φ and all the non-root nodesx have their value for ResolveSubtree(x) initialized to be equal to_{{f(x)}. For the root node,} since it does not have its clause representation inΦ, its value for ResolveSubtree is initialised to be equal to the empty set.

Example 5.3.1 Let(N, A, f) be the first support tree of example 5.2.1 where Φ = {¬b ∨ d ∨ f ∨ g, a ∨ b∨ c ∨ d, ¬a ∨ k ∨ j, ¬j ∨ d, ¬k, ¬c ∨ l, ¬l, ¬f}. The following represents the sequence of operations that corresponds to the application of algorithm 5.1 on(N, A, f).

GetSResolvents((N, A, f))

x =_¬d (1)

Visited(¬d) = true, x = ¬b ∨ d ∨ f ∨ g (4),(5)

Visited(¬b ∨ d ∨ f ∨ g) = true, x = a ∨ b ∨ c ∨ d (4),(5)

Visited(a ∨ b ∨ c ∨ d) = true, x = ¬a ∨ k ∨ j (4),(5)

Visited(¬a ∨ k ∨ j) = true, x = ¬j ∨ d (4)(5)

5.3. Algorithms 95

ResolveSubtree(¬a ∨ k ∨ j) = {¬a ∨ k ∨ j, ¬j ∨ d, ¬a ∨ k ∨ d} (8),(9)

x =¬k (11)

y =¬a ∨ k ∨ j (7)

ResolveSubtree(¬a ∨ k ∨ j) = {¬a ∨ k ∨ j, ¬j ∨ d, ¬a ∨ k ∨ d, ¬k, ¬a ∨ j, ¬a ∨ d} (8)

ResolveSubtree(¬a ∨ k ∨ j) = {¬j ∨ d, ¬k, ¬a ∨ j, ¬a ∨ d} (9)

x =_{¬a ∨ k ∨ j} (13)

y = a_{∨ b ∨ c ∨ d} (7)

ResolveSubtree(a ∨ b ∨ c ∨ d) = {a ∨ b ∨ c ∨ d, ¬j ∨ d, ¬k, ¬a ∨ j, ¬a ∨ d, b ∨ c ∨ d ∨ j, b ∨ c ∨ d} (8)

ResolveSubtree(a ∨ b ∨ c ∨ d) = {¬j ∨ d, ¬k, ¬a ∨ j, ¬a ∨ d, b ∨ c ∨ d} (9)

x =¬c ∨ l (11) Visited(¬c ∨ l) = true, x = ¬l (4),(5) y =¬c ∨ l (7) ResolveSubtree(¬c ∨ l) = {¬c ∨ l, ¬l, ¬c} (8) ResolveSubtree(¬c ∨ l) = {¬l, ¬c} (9) x =_{¬c ∨ l} (13) y = a_{∨ b ∨ c ∨ d} (7)

ResolveSubtree(a ∨ b ∨ c ∨ d) = {¬j ∨ d, ¬k, ¬a ∨ j, ¬a ∨ d, b ∨ c ∨ d, ¬l, ¬c, b ∨ d} (8)

ResolveSubtree(a ∨ b ∨ c ∨ d) = {¬j ∨ d, ¬k, ¬a ∨ j, ¬a ∨ d, ¬l, ¬c, b ∨ d} (9)

x = a∨ b ∨ c ∨ d (13)

y =¬b ∨ d ∨ f ∨ g (7)

ResolveSubtree(¬b ∨ d ∨ f ∨ g) = {¬b ∨ d ∨ f ∨ g, ¬j ∨ d, ¬k, ¬a ∨ j, ¬a ∨ d, ¬l, ¬c, b ∨ d, d ∨ f ∨ g} (8) ResolveSubtree(¬b ∨ d ∨ f ∨ g) = {¬j ∨ d, ¬k, ¬a ∨ j, ¬a ∨ d, ¬l, ¬c, b ∨ d, d ∨ f ∨ g} (9)

x =_¬f (11)

y =_{¬b ∨ d ∨ f ∨ g} (7)

ResolveSubtree(¬b ∨ d ∨ f ∨ g) = {¬j ∨ d, ¬k, ¬a ∨ j, ¬a ∨ d, ¬l, ¬c, b ∨ d, d ∨ f ∨ g, ¬f, d ∨ g} (8) ResolveSubtree(¬b ∨ d ∨ f ∨ g) = {¬j ∨ d, ¬k, ¬a ∨ j, ¬a ∨ d, ¬l, ¬c, b ∨ d, ¬f, d ∨ g} (9)

x =_{¬b ∨ d ∨ f ∨ g} (13)

y = root (7)

ResolveSubtree(root) = {¬j ∨ d, ¬k, ¬a ∨ j, ¬a ∨ d, ¬l, ¬c, b ∨ d, ¬f, d ∨ g} (8),(9)

returnResolveSubtree(root) (17)

The set of clauses returned by the algorithm is_{{¬j ∨ d, ¬k, ¬a ∨ j, ¬a ∨ d, ¬l, ¬c, b ∨ d, ¬f, d ∨ g} and} is the setSResolvents(Φ) of strong resolvents of Φ.

5.3.2

Algorithms for generating counterarguments

As described in paragraph 5.1.2, given an argument_{hΦ, αi, and the requirement to find all the canonical} undercuts for_{hΦ, αi from ∆, we can start by looking for all the arguments}

5.3. Algorithms 96 Args(¬ρ1) = hΨ11∪ Γ11,¬ρ1i, . . . hΨ1k∪ Γ 1 k,¬ρ1i .. . Args(¬ρn) = hΨn1∪ Γn1,¬ρni, . . . hΨnm∪ Γnm,¬ρni

for allρ1. . . ρn∈ SResolvents(Φ) from ∆ ∪ SResolvents(Φ) where Ψi⊆ ∆ and Γi⊂ SResolvents(Φ).

As explained in paragraph 5.1.2, we can use the set∆00= (∆ \ {δ ∈ ∆ | ∃ρ ∈ SResolvents(Φ) s .t. ρ ` δ_{}) ∪ SResolvents(Φ) as the knowledgebase from which all these arguments are generated. Also, as ex-} plained in section 5.2, although the support tree is defined with respect to a disjunctive clause and is rela- ted to finding arguments for claims that are clauses, we can use it to find arguments for a negated clause ¬ρi. For this we can construct a clauseρ0iconsisting of the literals ofρitogether with an arbitrary literal

p whose atom does not appear anywhere in ∆ or α, and hence anywhere in ∆00_.

Algorithm 5.2 GetCounterarguments((N, A, f)) Undercuts= ∅, Canonical = ∅

SResolvents(Φ) = GetSResolvents((N, A, f)) ∆00_{= RemoveSubsumedOf(∆, SResolvents(Φ))}

∆00_{= ∆}00_{∪ SResolvents(Φ)}

Letv be node that contains (N, A, f ) s.t. N ={x}, A = ∅, {f(x) | x ∈ N} = {p} for allρi ∈ SResolvents(Φ) do

ρ0

i = Augment(ρi, p)

∆00_{= ∆}00

∪ {ρ0 i}

P resupportT reesi= SearchTree(v)

for all (Nj, Aj, fj) ∈ P resupportT reesi do

if _{¬IsConsistent((N}j, Aj, fj)) then

P resupportT reesi= P resupportT reesi\ {(Nj, Aj, fj)}

else

if_{¬IsMinimal((N}j, Aj, fj)) then

P resupportT reesi= P resupportT reesi\ {(Nj, Aj, fj)}

end if end if end for

U ndercuts = U ndercuts∪ P resupportT reesi

∆00_{= ∆}00 \ {ρ0 i} end for Canonical= getCanonical(Undercuts) return Canonical

Then, a support tree(N, A, f) for ∆00_∪{ρ0_{i}, α}0= p and p indicates an argument for ¬ρiwhere the sup-

port of this argument is the set of clauses that represent(N, A, f) excluding clauses α0 = p and ρ0_i. Let function Augment(ρi, p) return ρ0ias described above, and let RemoveSubumedOf(∆, SResolvents(Φ))

return the set∆\{δ ∈ ∆ | ∃ρ ∈ SResolvents(Φ) s .t. ρ ` δ}. Then, given the support tree (N, A, f) that corresponds to argument_{hΦ, αi, algorithm GetCounterarguments((N, A, f)) returns the set of all ca-} nonical undercuts for_{hΦ, αi. For this, for each ρ}i ∈ SResolvents(Φ), a search tree Tiis generated by

algorithm SearchTree of chapter 4 forα0_{= p where the knowledgebase is ∆}00

∪{ρ0

i}. Each of the results

ofTiis then examined on whether it satisfies the conditions for a consistent and minimal presupport tree

by using function IsConsistent and algorithm IsMinimal introduced in chapter 4. The ones that do satisfy these conditions are added to setU ndercuts and the algorithm proceeds in the same way by building a treeTj associated to the nextρj ∈ SResolvents(Φ) using ∆00∪ {ρ0j} (where ρ0j = Augment(ρj, p)) as

5.3. Algorithms 97 the knowledgebase until all the clauses from SResolvents(Φ) have been examined.

After having generated all these arguments, the algorithm refines which indicate canonical under- cuts for_{hΦ, αi by comparing them with function getCanonical. The hΨ}is∪ Γis,¬ρii for which there is

no_hΨj_{l ∪ Γ}j_l,_¬ρji (where ρj may be equal toρi) such thatΨ j

l ⊂ Ψ

i

s, indicate a canonical undercut

hΨi

s,i for hΦ, αi. Because the literals from each ρi are linked to the literals of the clauses of each

supportΨi

s∪ ΓisforhΨis∪ Γis,¬ρii, it is more likely for a Ψj_l fromhΨj_l ∪ Γj_l,¬ρji to be contained in

Ψi

sfromhΨis∪ Γis,¬ρii when these are arguments for the same claim i.e. when it holds that ρi = ρj.

For this reason, function getCanonical first compares the supports for arguments that correspond to eachρi∈ SResolvents(Φ) individually and reject the ones that cannot indicate a canonical undercut for

hΦ, αi as described above. Then, it compares the supports for the remaining arguments of different ρi, ρj

and similarly it rejects the ones that according to proposition 5.1.3 do not indicate a canonical undercut for_{hΦ, αi.}