Zero-order logic and Eccles.
Ever since I found out about this very basic sort of logic, I've wanted to do things with it. It is otherwise called by
names such as sentence logic or propositional calculus, and is closely related to the logic
of binary electronics. It is the logic of AND, OR, and NOT, and a few other operators which can be derived from
these, and it underlies other logical formalisms.
Arguments in zero-order logic are conducted at a very low level. It uses names which denote assertions, and
symbols with which the assertions can be combined to give new assertions. For example :
Assertions : A, B;
New assertions : A & B; A -> B.
( pronounced "A and B", "A implies B" ).
There are certain rules for manipulating these assertions : for example,
( A & ( A -> B ) ) -> B.
Suppose that A stands for "It is raining" and B stands for "I am wearing my hat". The
the rule above can be expressed as :
"If it is raining,
if whenever it is raining it is found that I am wearing my hat
I am wearing my hat."
Statements like this are in some respects limited because they are very specific.
Most work in logic as treated in artificial intelligence uses first-order logic, or predicate
calculus. This is much more expressive than zero-order logic, because it can handle quantification, and can
therefore deal with general statements like "All cows eat grass". An argument in first-order logic
might look like this :
"If Daisy is a cow,
All cows eat grass
Daisy eats grass."
The two statements about Daisy in that argument are specific, and could be handled in zero-order logic - but the
But if first-order logic is so much more powerful. why bother with zero-order logic ? I have two reasons.
That's all very well, but what do I propose to do about it ?
- There are many problems in which you don't need quantifiers - and then they're a nuisance. Quantifiers are
good for abstract reasoning, but in many real problems the system is quite constrained, and it's easy to enumerate
all the items of interest. ( My original interest was in chemical reaction mechanisms, where the interesting
assertions were of the form "If reaction R occurs then substance S will be present". )
- At least one thing works a lot better in zero-order logic : negation. If you negate a precise simple statement,
you get another precise simple statement - either I am wearing my hat, or I am not wearing my hat. If you negate a
precise quantified statement, the result is not precise. "All is lost" is a precise statement; "All
is not lost" is another - but it means the same as "Nothing is lost", and isn't what you get by
negating the first statement. The result of the negation is "Not all is lost" - but that only means
"At least one thing of however many there might be is not lost", and we don't know just how many
things there are, nor how to find out the state of any one of them. Because of that, some things are rather harder
to manage in first-order logic than you might expect.
Eccles is, first and foremost, a character from the unique, inimitable, seminal, immortal, highly esteemed
GOON SHOW. Everyone knows that. Eccles is also an acronym : Environment for Computing with
Complicated Logical Expressions Simply. ( Eccles is also a town in Lancashire, known for Eccles Cakes. You can't
win them all. ) Here we are concerned with the second of these meanings.
This Eccles is a sort of logical workbench which I've been pottering with for a long time now. It isn't
specially complicated to do the logic processing ( though there are some tricky bits if you want to make it
reasonably efficient, as John Jensen discovered in a project ), but to make
it useful you want to be able to tie it in to other software, and finding a good way to do that has been interesting.
I have got some way with ELI ( the Eccles Logic Interpreter ), which accepts instructions to carry out logical
operations; it works, not too badly, but I haven't had time to look at it for a while.
Several students have put in some work on Eccles from time to time :
More if you want it :
WORKING NOTES :
AC47 ( Representing propositions in computers );
AC50 ( Eccles );
AC51 ( Eccles and higher-order logic );
AC53 ( Evaluating logical expressions ).
Go to me;
Go to Computer Science.