Let's start with a short quotation of Boole:

-They who are acquainted with the present state of the theory of Symbolic Algebra, are aware that the validity of the processes of analysis does not depend upon the interpretation of the symbols which are employed, but solely upon the laws of their combination.-

The common usage forces us to use the term Propositional Calculus (PC). However, we shall use it as a strict synonym of Boolean Algebra (BA). Operands and operators of BA are associated with a variable ranging over binary digits 0-1, which we call "Plausibility" for the sake of consistency with the Fuzzy Inference of our ultimate objective, the ERN Logic
(chapter "ERN LOGIC").

Original BA is 2 dimensional: its expressions consist of an operator taking plausibility of two operands as input and determining its own plausibility as output. Operands are determined uniquely as carriers of plausibility and don't admit other interpretation.

Operators may become in turn operands of higher level expressions, in which case they are treated as operands, i. e. plausibility carriers and nothing else. 2 dimensional BA admits 16 operators and in its improved Polish Notation of Lukasiewicz supports binary gates underlying computing and electronic technology.

Its pretended synonym, the pseudo-logical "Propositional Calculus" is a misnomer confusing Operand with "proposition" following noumenal Logic's traditional striving to be rooted in natural languages and via them in the noumenal reification. The same tendency confuses the binary, 0-1 range of plausibility with noumenalistic meaningless terms "truth-falsity". Throughout its history, noumenal Logic considered propositions as its unique operands. It never inquired where the "truth" of premises comes from, assumed it arbitrarily and dealt exclusively with its propagation to conclusions. Corrupted Boolean Algebra has been snatched and incorporated into noumenal Logic as an efficient propagation tool.

We have seen in "Natural Model" that, being an enhancement of the natural faculty, extrinsic logical systems may only be justified by extending and simulating the ER structures of the natural inferring faculty and the fuzziness of the physical reality.

While direct use of BA as "logical" Propositional Calculus is irrational, extended BA may be useful as a conceptual base of the rational Logic embodied in the ER Network (ERN). It will be presented in the chapter "ERN LOGIC". Here we shall briefly mention that ERN may be conceived as BA extended over:

1. Network structure with Operands in vertices and Operators in edges.

2. N dimensional vertices (associated with N edges), which involves a very fast increase of operators number (ON) in function of N: ON = 2**(2**N). Original 2D BA has 16 Operators which may be easily learned like the multiplication table and used spontaneously. For 3D we get 256 Operators and for
100 sensors watching malfunctions in a plane, 2**(2**100) Operators, whose enumeration, let alone definition would overflow the Congress Library. And the dimensions of DNA exceed 6000. We discuss practical ways of dealing with this problem in "N DIMENSIONAL PROPOSITIONAL CALCULUS" below. Let's note that dimensionality is local, determined for each vertex by the number of associated edges.

3. continuous plausibility spanning real number range {0-1} supporting fuzzy inference of the ERN logic.

4. Operands defined as, or reducible to Expressions, which makes ERN apt to formulate and to process most complex scientific and practical problems.

One might object to the apparent circularity: Logic being supposed to found Mathematics, cannot be properly founded in Boole Algebra, which is a mathematical construct. However, the circularity is only apparent. ERN is derived from inquiry about Mind and Reflection ("NATURAL MODEL") and our encounter with Boole Algebra during ERN derivation is coincidental.

2 DIMENSIONAL PROPOSITIONAL CALCULUS

Propositional Calculus (PC) is an instance of Boole Algebra defining operands and operators carrying binary variable taking values 0/1, which we call "plausibility" for the sake of consistency with Fuzzy Inference of the ERN logic.

"Propositional Calculus" is a misnomer confusing "operand" with "proposition" due to Logic traditionally striving to be rooted in Noumenal View as expressed by natural languages. The same tendency confuses the 0-1 range of plausibility with naive noumenalistic terms "truth-falsity". Throughout its history, Logic considered propositions as its only operands, was not concerned with the plausibility of premises, assumed arbitrarily and dealt exclusively with extending it to conclusions. It incorporated misnamed PC's algebra as an efficient extending tool.

Our phenomenal ERN Logic starts by inquiring how and to which operands plausibility may by premised before extending it to other conclusion-operands. In this latter task we find PC as a useful support, considering it strictly as algebra and disregarding its pretended linguistic implications.

For two-dimensional Calculus operators operate on 2 operands and have a plausibility variable being function of those of both operands. In order to comply with the common usage we may say that operator or operand is "true/false", implying by it the values "1/0" of Boolean binary plausibility.

For example operator "and" is true if and only if both operands are true, which may be symbolized for a couple of operands p, q as follows:

and(p, q)
1 1 1
0 1 0
0 0 1
0 0 0

For above 4 combinations of p, q we have clearly 16 operators
(o1-o16) listed below:

p q o1 o2 o3 o4 o5 o6 o7 o8
1 1 0 1 1 1 0 0 0 1
1 0 1 0 1 1 0 1 1 0
0 1 1 1 0 1 1 0 1 0
0 0 1 1 1 0 1 1 0 1

p q o9 o10 o11 o12 o13 o14 o15 o16
1 1 1 1 0 0 0 1 0 1
1 0 0 1 0 0 1 0 0 1
0 1 1 0 0 1 0 0 0 1
0 0 0 0 1 0 0 0 0 1

Following operators are most frequently used (Lists of their plausibilities may be more concisely shown as horizontal strings.):

operator horizontal string

o14: and 1000 o4: or 1110 o7: orr, exclusive or, either or 0110 o2: implica1ion 1011 o8: equivalence 1001

Operators may in turn become operands, which allows chains of operations, known as "inference chains", or shortly "inference" as shown in the simple example:

orr((and(p, q)),(or(r, s)))
1,0 1,0
0 1
1

Inference may extend over thousands of operations. Plausibilities of the lowest level (p, q, r, s) may be factual and inference determines their logical consequences. Besides the above mentioned binary operators the Calculus encompasses a unary operator "not" which operates on one operand and negates its plausibility replacing 1 by 0 and vice versa: not(p)
0 1
1 0

Besides the essential symbols, i. e. operators, operands and brackets, we shall introduce for convenience expressions, explained in the following example.

Example of Calculus' operations.

An expression marked "En" encompasses a main operator followed by bracketed structure of operators/operands. Expression has an associated plausibility string which it shares with the main operator. En, Em having identical strings are equal and marked En=Em. Otherwise, they are not equal and marked En!=Em. "=" symbol is also used to associate expression with its main operator: E1=and(pq). Operators and expressions can become in turn operands. Thus, searching, for instance, the solution of:

(1) if or(pq) implies and(pq) then X(pq) (where X is an unknown operator), we may write it in form of expressions:

E1=imp(or(pq).and(pq)) E2=X(pq) E3=or(pq) E4=and(pq) thus E1=imp(E3, E4)

We evaluate expressions starting by those in brackets: E3=or(pq)
1 1 11
1 1 10
1 1 01
0 0 00 E4=and(pq)
1 1 11
0 0 10
0 0 01
0 0 00 E1=imp(E3, E4)
1 1 1 1
0 0 1 0
0 0 1 0
1 1 0 0

Now, by equalizing E1 with E2 we may search X. E1=E2=X(pq)
1 1 1 11
0 0 0 10
0 0 0 01
1 1 1 00

Looking up the operators table we see that X=eq and we can write the solution of (1):

if or(pq) implies and(pq) then q is equivalent to p

The same chain of operations could be written without simplification by E3, E4 in one step:

E1=imp(or(pq).and(pq))=E2=eq(pq)
1 1 1 11 1 11 1 1 11
0 0 1 10 0 10 0 0 10
0 0 1 01 0 01 0 0 01
1 1 0 00 0 00 1 1 00

It seems more difficult, but with a little practice it becomes very easy to write directly such summaries even for much more complex expressions. However, when in doubt, it's advisable to follow Descartes and to decompose a complex expression into several simple ones.

Let's note: Calculus tells us that if or(pq) implies and(pq) then p and q are equivalent. Result not quite obvious and rather useful for instance in programming where we can replace "imp(or(pq).and(pq))" with simpler "eq(pq)".

Similarly: if(or(pq)) does not imply (and(pq)) then p and q are mutually exclusive: E1=not(imp(or(pq).and(pq)))=E2=orr(pq)
0 0 1 1 11 1 11 0 0 11
1 1 0 1 10 0 10 1 1 10
1 1 0 1 01 0 01 1 1 01
0 0 1 0 00 0 00 0 0 00

Exercise A

Many beginning programmers replace intuitively and wrongly E1=and(not(p),not(q)) with E5=not(and(pq))

It's difficult to explain them their error without help of the Calculus and very easy to do it with help Calculus.

1. Show the error.

2. Find correct X in E1=E2=not(X(pq)).

First using intermediary expressions E3=not(p) E4=not(q) and afterwards without them.

Exercise B

A theorem of Calculus says that any operator may be constructed from any two other ones with optional help of "and" and "not".

Show that "imp" may be constructed from "eq" and "or".

E1=imp(pq) = E2=or(eq(pq),and(not(p),q))
1 1 11 1 1 1 11 0 0 1 1
0 0 10 0 0 0 10 0 0 1 0
1 1 01 1 1 0 01 1 1 0 1
1 1 00 1 1 1 00 0 1 0 0

Thus E1=E2 QED

Exercise C

Show that "orr" may be constructed from "or" and "and".

N DIMENSIONAL PROPOSITIONAL CALCULUS

We have seen that for n=2, the 2-dimensional operators work on 2 operands (p, q) and that we have 2**(2**n)=16 operators:
1 1 1 1 1 1 1 p q 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6
1 1 0 1 1 1 0 0 0 1 1 1 0 0 0 1 0 1
1 0 1 0 1 1 0 1 1 0 0 1 0 0 1 0 0 1
0 1 1 1 0 1 1 0 1 0 1 0 0 1 0 0 0 1
0 0 1 1 1 0 1 1 0 1 0 0 1 0 0 0 0 1 The situation is simple, we know the 16 operators by heart, like the multiplication table and with a bit of practice can execute and program all operations of the 2d-PC from memory. For n2 PC becomes much more complex. Let's start with n=3 and 3 operands p, q, r: p q r

1 1 1 01111111
1 1 0 10111111
1 0 1 11011111
1 0 0 11101111
0 1 1 11110111
0 1 0 11111011
0 0 1 11111101
0 0 0 11111111 etc We have 2**(2**3)=256 operators. Number of operators increases very fast with n. For n=4 we have 2**(2**4)=65536 and for n=5
2**(2**5)=2**32=4294967296 operators. For practical applications
5 is small. We may have 20 symptoms of a disease or 100 "symptoms" of some breakdown in a jet plane. The respective diagnostic expert systems would extend over 2**(2**20) and
2**(2**100) operators. A bit to much to learn by heart, to describe in a textbook, or, for that matter, in the whole Congress Library. We have to look for some other procedures. Let's come back to n=3. Some operators map from n=2 to n=3 as one to one, ex. "and", "or": p q r and or

1 1 1 1 1
1 1 0 0 1
1 0 1 0 1
1 0 0 0 1
0 1 1 0 1
0 1 0 0 1
0 0 1 0 1
0 0 0 0 0 For any n they may be evaluated: "and" as product of all operands' plausibilities "or" as their maxof value. However, for n=3 "orr" forks to 3 distinct operators "one-of", "two-of" and "not-all": p q r one-of two-of not-all

1 1 1 0 0 0
1 1 0 0 1 1
1 0 1 0 1 1
1 0 0 1 0 1
0 1 1 0 1 1
0 1 0 1 0 1
0 0 1 1 0 1
0 0 0 0 0 0 For n=20 "orr" will fork to 20 operators, from one-of to
19-of and not-all. On this example we see that for higher n's only a few operators can be chosen from endless lists in function of their utility for a particular problem. As we have said before, the user has to tailor his logic to his problem by choosing pertinent operators and designing their evaluation algorithms. Evaluation algorithms for some operators may become a bit complex even in the Exact PC. They become really difficult in the Fuzzy.

Dimensions

Inference systems using PC are in general network structures. Each node is an Assertion. A node may be considered as an aggregate related top-down to several parts and as a part related bottom-up to several aggregates. A syndrome is an aggregate of its symptoms and a part of a disease. Relation Aggregate-part is "many-to-many": a syndrome may have several symptoms, a symptom may belong to several syndromes. Dimension of a node is the number of its parts.