AUSTIN programs: notions of alert, result and residue

We are now going to shift from a vision in term of “conversation between patterns”, to a vision in terms of “program execution” inside the conversational abstract machine:

Definition 9b:

Let Χ be a conversation frame, and

U

⁽

☺

) a set of initial definitive utterances emitted by a “user”:

- let us denote

X

(Χ) the set of startSteps associated to Χ

- let us denote

U

(Χ) the set of initial commissives associated to Χ - let us denote

U

⁽

☺

, X) = add (

U

⁽

☺

),

U

^(Χ)),

We call program and denote (

☺

, X) the conversation initial state: ωi = (

U

⁽

☺

^{, X),}

X

(Χ)).

If Χ is a cycle-free conversation frame, we may “derive” the initial state by applying the unique derivation rule:

ωi ⇒⇒ ωf = (

U

^(ωf),

X

^(ωf))

In the theory building process, the production and testing of a partial theory goes through the following steps:

1. likely hypotheses are embedded in one or several conversational patterns which together form a conversation frame X;

2. initial facts are described as a set of assertives;

3. the enquiry is described through one or more assertives or directives requesting some result of the computation;

4. the order to start is given …

5. … the abstract conversational machine derives the initial state until it halts on a final state and emits ‘end’;

6. the newly emitted assertives constitute the ‘predicted results’, logically deduced from the initial facts and patterns.

4. and 5. are illocutionary acts in a man-machine conversation; according to Searle and Austin, they are declarations⁶⁶:

- ‘4.’ is the declaration by the user that “conversation has started”, which actually starts the conversation;

- ‘5.’ is the declaration by the abstract machine that “conversation has come to an end”, which actually end the conversation; it is sometimes coded as an “end” instruction in programs.

An extensive description of the conversation requires that borderline utterances are taken into account; we therefore add the sentences ‘start’ and ‘end’ to S to the grammar described in [3.9] without interfering with the calculus itself:

- the type ‘DEC’ for ‘declarations’ is added;

- the roles ‘input’ and ‘output’ and the concept ‘Message’ are added.

Illocutionay act Utterance

declaration (([input: Message: ‘start’]; DEC),0, {USER}) (([output: Message: ‘end’]; DEC),0, {AUSTIN})

66 “In a declaration, the illocutionary point is to bring about a change in the world by representing it as having been changed. [Searle, 1999]”

4.2.1 Acceptability of programs

There are two conditions for a program to be successfully run by the abstract machine:

1. the conversation frame must be cycle-free : this will be checked in [4.4.1] by analyzing the directed graph defined on the conversation frame X by the relation

“potentiallyTriggeredBy” between the startNodes ;

2. reducers embedded in conversation nodes must be correctly written⁶⁷ by the

‘programmer’!

To these two conditions, we are going to associate two expressives⁶⁸, emitted by the abstract machine whenever the conditions are not fulfilled, and addressed to the ‘user’

just before halting (these are sometimes coded as ‘exceptions’ in programs).

Again, we indicate how the associated sentences can be added to the grammar of [3.9] in order to avoid interference with the calculus:

- the type ‘EXP’ for ‘expressive’ is added;

- the role ‘alert’ is added.

Illocutionay act Utterance

expressive (([alert: Message: ‘cycle in triggering!’]; EXP),0, {AUSTIN}) (([alert: Message: ‘invalid node!’]; EXP),0, {AUSTIN}) Definition 9c:

Let Χ be a conversation frame, and

U

⁽

☺

) a set of initial definitive utterances emitted by a “user”.

Let us consider the program (

☺

, X). The results of the global checking of cycles and of the local checking of reducers are expressives does not depend on

U

⁽

☺

); we store theses results in Alerts (∅, Χ)

(

☺

, X) is an acceptable program if and only if Alerts (∅, Χ) = ∅.

67We have defined reducers as 2^A×2^B→ 2^B functions, it might happen that the node written by the ‘programmer’

does not accept all possible entries from 2^A×2^B, or does not output in 2B; this must be locally checked either at execution or at compilation.

68 “Examples of expressives are apologies, thanks, congratulations, welcomes, and condolences. [Searle, 1999]”

4.2.2 Residue and result of an acceptable program Let (

☺

, X) be an acceptable program:

ωi = (

U

⁽

☺

^{, X),}

X

^{(X)) ⇒⇒ ωf = (}

U

^(ωf),

X

^(ωf))

Among the steps

X

^(ωf) are all those which have reached their definitive state and therefore have the status ‘0’; let us denote them

X

^0(ωf) and let us denote

X

^1(ωf) the set of final steps having kept the status ‘1’. It may happen that

X

^1(ωf) = Ø: these are very good news indicating that each invocation has been allowed to reach its final state. It may also happen

X

^{1(ωf) =}

X

(X), these are bad news indicating either that no utterance in

U

⁽

☺

^,

X) has played the role of trigger for any startStep of

X

(Χ) and in this case we also have

U

^{(ωf) =}

U

⁽

☺

^{, X).}

The notions of residue and result aim at formalizing these notions:

Definition 9d:

Let Χ be a conversation frame, and

U

⁽

☺

) a set of initial definitive utterances emitted by a “user”.

If (

☺

, X) is an acceptable program the conversation can be run by the abstract machine:

(

U

⁽

☺

, X),

X

^{(Χ)) ⇒⇒ ωf = (}

U

^(ωf),

X

^(ωf))

U

^{(ωf) =}

U

^{0(ωf) ∪}

U

^1(ωf) where utterances of

U

^0(ωf) have status = ‘0’ and utterances of

U

^1(ωf) have status = ‘1’

X

^{(ωf) =}

X

^{0(ωf) ∪}

X

^1(ωf) where steps of

X

^0(ωf) have status = ‘0’ and steps of

X

^{1(ωf) have}

status = ‘1’

We therefore define:

Residue (

☺

, Χ) = (

U

^1(ωf)),

X

^1(ωf)) is the part of the final state consisting in non- definitive utterances and non-activated steps

Result (

☺

^{, Χ) = (}

U

^0(ωf),

X

^0(ωf)) is the part of the final state consisting in definitive utterances and activated steps

4.2.3 Checking the acceptability before running the conversation

If programs are not acceptable, some alerts must be raised. We propose to integrate the preliminary checking for acceptability at the beginning of the derivation:

Definition 9e:

Let Χ be a conversation frame, and

U

⁽

☺

) a set of initial definitive utterances emitted by a “user”.

Let us denote:

|⇒⇒

the operation consisting in checking acceptability and then (eventually) computing the program:

(

U

⁽

☺

, X),

X

^{(Χ)) |⇒⇒} (Alerts (∅, Χ), Residue (

☺

, Χ), Result (

☺

, Χ)) - (

☺

, X) is an acceptable program if and only if Alerts (∅, Χ) = ∅

- (

☺

Χ, X) is a concluding program if and only if Alerts (∅, Χ) = ∅ and Residue (

☺

, Χ)

=∅.

No documento Collaborative theory construction: towards a conversational abstract machine (páginas 161-165)