Logical deduction in AUSTIN

fail for every other clause C’ in P, then A can participate neither in a ‘reduce’ transition nor in a ‘fail’

transition. Such a goal atom is called suspended. A state consisting of a goal in which all atoms are suspended is terminal, as no transition applies to it. Such a state is called a dead-lock state, and a computation ending in a deadlock state is called a deadlocked computation.”

In concurrent programming languages, a finite computation is a succession of states (G1, ε), (G2, θ2), … (Gn, θn) leading to an observable behaviour (G1,θ, x) where:

- G1 is the initial goal;

- θ is the answer substitution of the computation;

- x = true (case Gn= true) OR fail (case Gn= fail) OR deadlock.

In AUSTIN, instead of a system based on clauses, we have the following three transition rules recapitulated [3.6.2]:

[testInvoke (xP0, u, ω) = ((xP0, u), true)] → invoke (xP0, a) [testActivate (xP1, ω) = ((xP1, A¹), true)] → activate (xP1, A¹) [testRevoke (xP0, ω) = (xP0, true)] → revoke (xP0)

When for instance we look deeper into testRevoke, we read in Definition 7c:

“Let ‘ω’ be the current state of the conversation:

[testRevoke (xP0, ω) = (x, true)] ⇔ [(cond¹ = true) and (cond² = true)]

- cond¹ first verifies that no more potential triggers exist for the starter of χ_P⁰, then verifies that all definitive triggers for the starter of χ_P⁰ have gone through the corresponding invocation: cond¹ = [PotentialTriggersFor (sP, ω) = ∅ and (∀u = (a, 0)∈ DefinitiveTriggersFor (sP, ω)) (xP0, a, 0) ∈X(ω)]

- cond² verifies that the revocation has not already occurred: cond² = [(χP0, ∗, 1) ∈X(ω)]”

In cond¹, we have twice the expression ‘∀u’: one is visible in the formula, the other one is hidden in PotentialTriggersFor (sP, ω) = ∅. Since we have defined ‘u’ as a predicate, this means we are operating a second-order calculus on predicates!

Moreover, whenever testRevoke answers ‘true’, we apply Definition 6c:

“revoke (xP0) is the atomic transition from state ω to state ω’ consisting in the following actions:

1. for each “s” in E I0∪F I0 remove ((s, 1), (χP, ∗)) from

U

2. remove (xP0) from

X

It appears that two kinds of atoms (utterances and predicates) are removed!

Our mapping has then two be completed in the following way:

AUSTIN concepts terms, atoms, formulas

test (invoke, activate, revoke) second order formula (quantifiers operate on predicates) transition (invoke, activate,

revoke)

second order formula (either remove must be considered as a predicate operating on predicates, or a third status ‘-1’ has to be considered)

Table 15: Mapping between AUSTIN and logic / 2

It appears that the AUSTIN machine could be described as a concurrent second order calculus, where lists of atoms are created as a function of lists of atoms by the reducers.

This logical formalization is out of the scope of this thesis; we only emphasize three points here:

The Close World assumption

In answering questions, as well as in triggering patterns, we have implicitly relied on the default assumption that all that is true is expressed in atoms; this is a variant of the Closed World Assumption.

When we look closer into what happens during the AUSTIN conversations, we see that atoms are generated when commissives are reduced into assertives or directives: the

“close world” is the world of what is present in the conversation as well as the potential output expressed by the commissives.

According to formalization choice, we may or not use logical negation (e.g. for expressing the fact that PotentialTriggersFor (sP, ω) = ∅; the alternative being the creation of appropriate predicates.

Other possibilities are closer to operational semantics: “negation as failure” is an interpretation of logical negation according to which the negation of a formula is true if and only if the formula cannot be proved true. In PROLOG [Colmerauer and Roussel, 1992]

for instance, the absence of evidence equals evidence for absence. It even happens that both logical negation and negation as failure are used, like in answer set programs [Lifschitz, 2002].

Monotonicity

The consequence relation for a given logic is monotonic when adding a formula to a theory never produces a reduction of its set of consequences. This is interpreted as a monotonic increase in the knowledge and subsequently disallows reasoning techniques such as ‘reasoning by default’ (facts may be known only because of lack of evidence of the contrary), ‘abductive reasoning’ (facts are only deduced as most likely explanations),

‘reasoning about knowledge’ (the ignorance of a fact must be retracted when the fact becomes known), and ‘belief revision’ (new knowledge may contradict old beliefs).

AUSTIN conversations are monotonic in the sense that atoms obey the following production rules (a unique partial order ‘≤’ is mentioned whereas it has different definitions for utterances and steps; ‘-1’ is used to indicate ‘removal’):

utterance (sentence, 1) -> utterance (sentence’, 1) sentence’ ≤ sentence utterance (sentence, 1) -> utterance (sentence, -1)

utterance (sentence, 1) -> utterance (sentence, 0)

step (node, *, 1) -> step (node’, sentence, 1) node’ ≤ node ; sentence ≤ * step (node, sentence, 1) -> step (node’, sentence, 1) node’ ≤ node

step (node, sentence, 1) -> step (node’, sentence, 0) node’ ≤ node step (node, sentence, 1) -> step (node, sentence, -1)

According to this draft of grammar, only utterances which have ‘status = 1’ (which means: neither definitive nor removed) may play the role of left members in the production rules. Right members are always “terminal”. True knowledge, corresponding to assertives (with status = ‘0’) increases through successive reduction of commissives.

Goal driven versus Event driven

In the computation pattern provided by Shapiro for concurrent logic languages, the ultimate goal is initially known and the challenge consists in finding a proper substitution for establishing a logical path between available data and the goal. This is based on concurrent blind “unification-tries” until a path is found; if all attempts fail, the global result is failure. Shapiro emphasizes that in order to deserve the name of logic programming language, each successful computation must correspond to a proof of the goal statement. According to his survey, the difficulty seems to be in articulating concurrency with systematic exploration of the tree of possible unifications.

AUSTIN is not goal driven, and therefore cannot match Shapiro’s framework. AUSTIN instantiates simplified conversations between pre-existing theories; propagates the initial context through automatic substitutions operated by the reducers, and benefits from a semantically driven concurrency⁷⁶. The recording of the conversation traces a logical path between initial context and final consequences through an automatic articulation of the

‘partial theories’.

76 this was illustrated in the Sudoku example where CELL and SET were invoked for all contexts (place in the grid, state in the reasoning) in parallel