Logical interaction between artefacts

3. a subset ‘L’ of Σ*, called ‘formal language’ because its expressions are formally constrained by a finite set of rules, is defined. These rules can be production rules:

in such a case, the expressions of ‘L’ are obtained by ‘derivations’ consisting in a finite number of applications of rules upon a finite set of initial expressions. Or they can be recognition rules: in such a case, the expressions of ‘L’ are those resulting from a valid ‘parsing’ through a finite number of tests.

There is a great variety of ways for specifying formal languages:

- in generative grammars, expressions are built through successive rewritings.

Formal grammars for instance are based on a finite set of rules modifying one part of a word at a time; they give birth to recursively enumerable languages.

In linguistics and computer science, a context-free grammar (CFG) is a formal grammar in which every production rule is of the form “NT → w”, where NT is a non-terminal symbol and w is a string consisting of terminals and/or non-terminals; context-free grammars allow syntax checking through parsing algorithms and are powerful enough to describe the syntax of many programming languages.

- it may happen also that the strings of the formal language are produced by a regular expression, i.e. a string matching a set of strings according to a set of rules;

- in analytic grammars, expressions are ‘parsed’ through a number of tests before being accepted or rejected;

- some languages are recognized by a given automaton, i.e. a self-operating machine, simpler of equivalent to a Turing Machine²⁸.

- others are defined as positive results of some decision problem, i.e. a question with a Yes/No answer.

Two major theoretical questions, or ‘decision problems’, occur about formal languages:

a) Syntax checking: is a given succession of expressions a valid ‘derivation’/

‘parsing’?

b) Theorem proving / Recognition: is it possible to find a valid ‘derivation’/

‘parsing’ for a given expression?

28 Turing Machines are presented further in this sub-section

Due to the finite grounding of formal systems, the ‘syntax checking problem’ is always decidable (it can be given an answer in finite time through a deterministic procedure).

On the contrary, since the number of times each rule can be conveyed in a ‘derivation’/

‘parsing’ are not bounded, the number of possible expressions is not bounded. The consequence is that the ‘Theorem proving/ Recognition’ problem is generally not decidable.

[8.2] gives a first hint about the power and limits of formal languages. On one hand a simple ‘Post System’ can serve as a foundation for the Propositional Calculus; on the other hand the “Post correspondence problem”, which questions the possible derivations inside a Post System, is not decidable.

As exposed in [Alliot & Schiex, 1993], Hilbert proposed in 1908 to provide formal grounding for Mathematics in order to prove their consistency (impossibility to formally derive a expression AND its negation within the system). His students started to work on this program in 1920, focusing their efforts on Arithmetic … until Gödel and then Kleene proved the consistency of Arithmetic to be improvable! Moreover, Arithmetic is undecidable (there is no decision procedure for ‘Theorem proving / Recognition’) and uncomplete (there are formulas such that neither the formula nor its negation can be

‘proved / recognized’)

It seems that the more expressive a formal language is, the more difficult it is to reason upon it, in particular when some kind of auto-reference can be simulated inside the language.

At a minimum, the question: “is this sequence of expressions a correct application of the syntactic rules of the formal language?” will always get an answer; this is what we are intending to build upon.

Turing Machines

When formal languages are not explicitly generated, they have to be recognized by some formally defined ‘self-operating’ machine, i.e. machines obeying to a “computation model”. Among several equivalent computation models, Turing Machines are the most famous.

Turing machines were born in 1936, at a time when Church, Gödel, Kleene, Post and Turing were working on the notion of formal systems and calculi; Alonzo Church, Stephen Cole Kleene and Kurt Gödel were looking for a universal model for intuitively

calculable functions, while Emil Post and Alan Turing took the view point of a universal model for effective computation by machines. One of the major conclusions of this community of mathematicians, with the status of a very widely admitted conjecture, is known as the Church-Turing thesis: “For a function, to be intuitively calculable or to be Turing calculable are equivalent”. Another formulation, better suited to our purpose is the following: “any possible calculation can be performed by an algorithm²⁹ running on a computer, provided that sufficient time and storage space are available”. The functions from natural numbers to natural numbers which can be computed by Turing machines are called recursive functions.

http://en.wikipedia.org/wiki/Turing_machine gives an informal definition of Turing Machines:

“A Turing machine consists of:

1. A tape which is divided into cells, one next to the other. Each cell contains a symbol from some finite alphabet. The alphabet contains a special blank symbol (here written as '0') and one or more other symbols. The tape is assumed to be arbitrarily extensible to the left and to the right, i.e., the Turing machine is always supplied with as much tape as it needs for its computation. Cells that have not been written to before are assumed to be filled with the blank symbol.

2. A head that can read and write symbols on the tape and move left and right one (and only one) step at a time.

3. A state register that stores the state of the Turing machine. The number of different states is always finite and there is one special start state with which the state register is initialized.

4. An action table (or transition function) that tells the machine what symbol to write, how to move the head ('L' for one step left, and 'R' for one step right) and what its new state will be, given the symbol it has just read on the tape and the state it is currently in. If there is no entry in the table for the current combination of symbol and state then the machine will halt.”

This very simple model of computation was not aimed at building effective computers;

but at giving an insight about what computers can do… or not … In [Turing, 1937] it was

29 [Knuth, 1973]: “It is generally assumed that an algorithm must satisfy the following five requirements:

- Finiteness: An algorithm must always terminate after a finite number of steps … a useful algorithm should require not only a finite number of steps, but a very finite number, a reasonable number

- Definiteness: Each step of an algorithm must be precisely defined; the actions to be carried out must be rigorously and unambiguously specified for each case

- Input: ...quantities which are given to it initially before the algorithm begins. This inputs are taken from specified sets of objects

- Output: i.e., quantities which have a specified relation to the inputs

- Effectiveness: ... all of the operations to be performed in the algorithm must be sufficiently basic that they can in principle be done exactly and in a finite length of time by a man using paper and pencil”

shown that the particular (Halting) problem of determining whether any particular Turing machine will halt on a particular input was not decidable. [Rice, 1953] even demonstrates that no machine can always correctly decide whether the language of a given Turing machine has a particular ‘nontrivial property’ (such as halting on a particular input).

It is considered³⁰ that what we call ‘computers’ behave like “universal Turing Machines”;

they are able to calculate any recursive function, decide any recursive language, and accept any recursively enumerable language (but not recognize it because of the Halting problem).

Among computation models equivalent to Turing machines, we find:

- “Formulation 1” in [Post, 1936]

- [Minsky, 1967]’s computational model with only two instructions i) add 1 to the number in register, and go to next instruction; ii) if number “n” in register is not zero then subtract 1 from it and go to the next instruction, otherwise go to the n^th instruction

- Normal Markov Algorithm

- … and some others, like the “Kolmogorov-Uspensky machines” ³¹ relying on what [Gurevich, 1988] calls “real-time algorithms”: “A real-time algorithm inputs a symbol, then outputs a symbol within a fixed number ‘c’ of steps, then inputs a symbol, then outputs a symbol within ‘c’ steps, and so on. In the case of more powerful machines, one may want to speak about more complicated data items (than just symbols) as one-step inputs or outputs.”

In order to sustain the conversation between the machines of “Convivial Coffee”, we need such algorithms; however we shall use the denomination “multi-steps algorithms” in place of “real-time algorithms” in order to avoid the confusion with software systems having operational deadlines from event to response.

30 None of them is equipped with an « infinite tape », but we can always build a storage capacity large enough for any computation.

31 Among other computation models, we read in [Durand, 2004] that Kolmogorov proposed under the name of

“Kolmogorov-Uspensky machines” a computation model in which all others could integrate. These machines are described in [Kolmogorov, 1963] and in [Uspensky, 1990]. The computation model relies on a tape being a finite directed connected graph able to change its topology by addition or removal of edges and nodes. We have not entered in the details of these machines, but will also need an evolving directed graph as a support for control of conversation in the calculus presented in Chapter 3.

Towards a ‘logically ruled’ interaction

Starting from the definition of [Magnani, 2001]: “Deduction is an inference that refers to a logical implication. Deduction may be distinguished from abduction and induction³² on the grounds that only in deduction is the truth of the conclusion of the inference guaranteed by the truth of the premises on which it is based. Deduction refers to the so-called non-defeasible arguments.”, we are going to use formal languages for an informal definition of ‘logical deduction’ is the context of collaborative theory building .

What Magnani emphasizes in ‘deduction’ is the succession of arguments which guarantees a correct “transmutation” of true expressions into other true expressions. The question of the truth or falsity of expressions itself involves experimental facts and minds able to interpret them, and will be addressed in [2.1.3]. What is in question here is the correctness of the process: either the ‘derivation’ process linking facts and hypotheses to new (expected) facts or the ‘recognition’ process analyzing composed expressions.

The correctness of the process is exactly what formal languages are about; the additional property we shall require from an abstract machine aimed at composing ‘partial theories’

is based on ‘confluence’, hereafter defined in http://en.wikipedia.org/wiki/Confluence :

“We can think of a rewriting system abstractly as being a set S, together with a relation R which is a subset of S×S. Instead of denoting relations as pairs (s, t), with s, t ∈ S, we write s →_i t, where i is from some index set I. If u ∈ S, and u →_j v for some j ∈ I, then we say v is a reduct of u (alternatively v is an expansion of u, or u is reduced to v). We can also think of a chain of reductions of some element: if w ∈ S, then we may have

w →i1 w1 →i2 w2 →i3 w3

where i_k ∈ I. We call this chain a reduction sequence, or just a reduction of w. If the reduction sequence terminates, say in wn, we write

w →_I^* w_n

reflecting that relations in I were chosen. If I is clear from context then we can omit this subscript.

With this established, confluence can be defined as follows. Let a, b, c ∈ S, with a →* b and a →* c. If a is confluent, there exists a d ∈ S with b →* d and c

→* d. If every a ∈ S is confluent, we say that → is confluent, or has the Church-Rosser property. This property is also called the diamond property, after the shape of the diagram shown on the right.”

32 ‘abduction’ and ‘induction’ will be defined in [2.1.3.2]; in first approximation, ‘abduction’ relies to intuitive hypotheses while ‘induction’ goes from particular facts to generalizing hypotheses.

Let us consider an abstract machine in charge of automatically ruling the interaction between ‘multi-steps algorithms’³³ embedding ‘partial theories’³⁴. A first hope would have been to have the machine answering questions of the type “is this expression a theorem?”; but according to the general case, theorem proving is not decidable. Instead, we may benefit from two aspects:

- each global derivation will lead to CORRECT EXPRESSIONS;

- if (and only if) the abstract machine is confluent, each global derivation will depend on only two things: i) the partial theories and ii) the interaction rules; it will therefore behave globally as a determinist logical artefact. In such a case, the result of the rewriting can be interpreted as THE LOGICAL³⁵ CONSEQUENCE WITHIN THE FORMAL SYSTEM of the interaction of partial theories.

We first suppose a formal language able to integrate multi-steps algorithms as local rewriting systems and to rule their interaction in a confluent way.

We propose to call ‘logical consequence of the interaction within the formal system’ the result of the global rewriting.

In order to illustrate the logical composition of partial theories, we must now formalize the notion of ‘theory’; this is the subject of next sub-section.

33 in the sense of [Knuth, 1973] extended by [Gurevich, 1988]

34 to be defined in the next sub section

35 We use the adjective ‘logical’ in contrast with the adjective ‘selectionist’ of the present sub-section.