Refining the theory

Principle three:

- invocations of ‘conversational patterns’ are decided on the basis of “pertinent”

assertives and directives;

- revocations of ‘conversational patterns’ are decided when all “pertinent” commissives have been removed.

The word “pertinent” is used here in an intuitive way and will be substituted in Chapter 3 by two formally defined relations between sentences: the relation “answerFor” will establish the pertinence in case of Principle two, while the relation “triggerFor” will establish the pertinence in case of Principle three.

We may now recapitulate:

i) we suppose a conversational abstract machine:

- respecting Principles one, two and three

- embedding control rules for ‘answering questions’ and ‘invoking/revoking conversational patterns’.

ii) the first version of the candidate theory consists of the following:

- the ‘givens’ describing the ‘initial grid’ are input as assertives: “value ‘z’

accepted for cellxy ”

- an initial directive: “what solution for sudoku?” is also input at the beginning in order to start the coputation

- a ‘conversational pattern’ LAUNCHER first announces by its commissive and then asserts the contexts for the cells

- a ‘conversational pattern: CELL’ with its proper commissives which will be substituted by the contextualized assertives (b.) & (d.) and directives (a.) & (c.)…

iii) the moderator invokes LAUNCHER then concurrently invokes ‘CELL’ under the 9×9 contexts. Each ‘cell with an already accepted value’ informs its neighbours that this value must be rejected for them. Each cell asks about its rejected values. Hopefully one or more cells count only one remaining value and accept it …

- each cell first emits the commissive: “value ‘v’ is my accepted value” which pre- announces some further assertive: “this value is my accepted value”

- each cell then emits the directive: “have I already got an accepted value?”

- in order to answer the directive, the moderator must wait for the commissive to be removed, but this can happen only when the answer is received … we have a dead-lock! Moreover, the mutual informing and questioning about rejected values between neighbours creates another deadlock!

The responsible for this state of affairs is the current conceptualization: ‘time’ has not found its place in the concurrent conversations, how could they (the friends of 1895) hope any progress in the collaboration between cells?

A first necessary extension of the language is therefore the addition of a new concept:

the concept of ‘state in the resolution’:

- the ‘initial grid’ is labelled ‘state 0’

- the 81 cell invocations gather information from ‘state 0’ and produce ‘state 1’ … - then gather information from ‘state 1’ and produce ‘state 2’ …

More precisely, ‘time’ has been incorporated in the theoretical concept ‘state’, which together with ‘row’ and ‘column’ settles a three-dimensional referential, and the conversation becomes:

- cellxy / directive/ to moderator: “have I already got an accepted value at state

<=‘n’?”

- cellxy / assertive/ to moderator: “this value is rejected for my neighbours at state

‘n+1’ ”

- cellxy / directive/ to moderator: “what are my rejected value at state <=‘n’?”

- cellxy / assertive/ to moderator: “this value is my accepted value at state ‘n+1’ ” Instead of a ‘conversational pattern’ invoked in 81 contexts (x, y) , we now have a new one invoked in 81× ‘number of states’ contexts (x, y, n).

A detailed examination of this new conceptualization would show that all the concurrent invocations auto-organize⁴⁸: although questions about all states ‘n’ are simultaneously asked, the causal dependency coded inside the patterns (questioning state ‘n’ and

48 As a drawback, the number of states has to be given a pre-defined value, otherwise the ‘conversational pattern’

cannot be revoked and its initial commissives prevent any answer; this number is necessarily smaller than 81 since the whole approach will be successful only if one new value at least is accepted at each state!

asserting state ‘n+1’) automatically induces a chronology of answers corresponding to states ‘0’, ‘1’, ‘2’ … via the answering rule!

It will be shown in [4.6] that this second version of the theory incorporating time works without deadlocks … but unfortunately stops before filling the initial grid completely, by lack of deductive power!

To remedy this last point, another extension of the language is required, including the introduction of an additional reasoning pattern embedding the viewpoint of a ‘set’ of cells (a set is either a row or a column or a region):

additional concepts and function

- ‘seti’is one of the 27 sets (9 rows + 9 columns + 9 regions);

- cells (seti) is a function enumerating the 9 ‘cellxy’ of a ‘seti’

Table 4: completing the description language for 'Sudoku'

To ‘seti’ we associate the following speech acts:

g. seti / directive/ to moderator: “what are my accepted (value, cell) at state <= ‘n’”?

h. seti / directive/ to moderator: “which values are rejected for my empty cells at state <= ‘n’”?

i. seti / assertive/ to moderator: “this value is accepted for that cell at state ‘n+1’ ” for my neighbours”

j. seti / assertive/ to moderator: “this value is rejected for neighbours of that cell at state ‘n+1’ ”

These speech acts integrate into a partial theory obeying the following ‘conversational pattern’ SET:

- “emit(g.); wait for answer” … - “emit(h.); wait for answer” …

- IF answers to (a.) is positive THEN: “emit (b.); end” ELSE: “emit (c.); wait for answer” …

- IF answer to (g.) and (h.) are such that only one value is remaining for one cell inside the set THEN: “emit(i.); emit(i.); end” ELSE:“end”

The interesting point is that this new ‘conversational pattern’ SET is simply added to CELL

without any additional effort.

This third version of the theory is the good one: a concurrent conversation between

LAUNCHER, CELL and SET involving ((81בcellxy’+27בseti’)×15 ‘states’) invocations successfully solves the ‘Sudoku n° 53’ given at the beginning of this chapter, as it will be presented in more details in [3.10] and [4.5.2].