In one of the letters written to the Infeld group in Warsaw Einstein wrote:
"A new manner of thinking is essential if humankind is to survive."

After Carnap, Logic has to satisfy following requirements:

-Fuzzy, "swampy", gray "probability" or "certainty" replacing the traditional black and white "truth/falsity",

-Axiomatic ultimate premises similar to Popper's "piers" driven into "swamps",

-Factual ultimate conclusions similar to physical observations,

-Unlimited dimensionality allowing to deduce from any number of premises and to induce from any number of conclusions, which implies network as fundamental logical structure.

-Customized logic: algorithms of fuzzy operators vary from application to application.

We show a small example of a logical system satisfying all those requirements in FUZZY LOGIC EXAMPLE

Exact Two-dimensional Propositional Calculus.

Propositional Calculus encompasses operands and operators. Operands are statements with which we associate a variable "certainty".

For Exact Calculus certainty may take one of two values: "true" and "false", symbolized respectively with "1","0". For simplicity's sake we shall say that a statement is true, or that its value is 1, always implying the certainty of the statement.

For two-dimensional Calculus operators operate on two operands and have a certainty variable being function of those of both operands. As for operands, we shall say "operator is true/false", implying by it its certainty.

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 particularly important: (Lists of their certainties 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 "inferencing" as shown in the simple example:
orr((and(p,q)),(or(r,s)))
         1,0       1,0
     0          1
1
Inferencing may extend over thousands of operations. Certainties of the lowest 
level (p,q,r,s) may be factual and inferencing 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 certainty 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 certainty 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 and searching, 
for instance, the solution of:
(1) if and(pq) implies or(pq) then X(pq) where X is an unknown operator.
We may write it in form of expressions:
E1=imp(and(pq).or(pq)) 
E2=X(pq)
E3=and(pq)  
E4=or(pq)
thus E1=imp(E3,E4)
We evaluate expressions starting by those in brackets:
E3=and(pq)
1  1   11
0  0   10
0  0   01
0  0   00
E4=or(pq)
1  1  11
1  1  10
1  1  01
0  0  00
E1=imp(E3,E4)
1  1   1  1
0  0   0  1
0  0   0  1
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 and(pq) implies or(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(and(pq).or(pq))=E2=eq(pq)
1  1   1   11  1  11   1  1  11
0  0   0   10  1  10   0  0  10
0  0   0   01  1  01   0  0  01
1  1   0   00  0  00   1  1  00
It's 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 and(pq) implies or(pq) then p and q 
are equivalent.
Result by no means obvious and quite useful for instance in programming where 
we can replace "imp(and(pq).or(pq))" with much simpler "eq(pq)".
Similarly:
if(and(pq)) does not imply (or(pq)) then p and q are mutually exclusive:
E1=not(imp(and(pq).or(pq)))=E2=orr(pq)
0  0   1   1   11  1  11    0  0   11
1  1   0   0   10  1  10    1  1   10
1  1   0   0   01  1  01    1  1   01
0  0   1   0   00  0  00    0  0   00
===============================================================================
EXERCISE B
 
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 using 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 C
 
A theorem of Calculus says that any operator may be constructed from any two  
other ones with optional help of "and" and "not".
 
Example:
--------
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:
---------
Show that "orr" may be constructed from "or" and "and":
------------------------------------------------
EXACT ND PROPOSITIONAL CALCULUS (PC)
------------------------------------------------
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 n>2 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. 
And for practical applications 5 is small. We can 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' certainties 
"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 AND CHAINING.
------------------------
Inferencing systems using PC are in general network structures. Each node is 
a statement. A node may be an aggregate related to several parts and, in turn, 
a part related to several aggregates.  A syndrom is aggregate with respect to 
its symptoms and part with respect to one or more diseases. Aggregate-part 
relation is many-to-many: a syndrom may have several symptoms, a symptom may 
belong to several syndroms.
By dimension of a node we understand the number of its parts. The lowest level 
nodes the "pure parts" having no parts themselves have their certainties set 
factually: by a doctor observing symptoms, by security sensors in the circuits 
of a plane, etc.
Then in the so called "backward chaining" certainties of aggregates are 
recursively evaluated in function of those of their parts. Parts are considered 
as operands and operators are determined by the relations part-aggregate.
We can see two rather difficult problems:
1.One cannot talk about dimensionality of the whole inference system, but of 
each of its nodes.
2.Each part may be related to aggregate via different operator. Some may be 
considered as necessary (and), some as optional (or), some as exclusive (one-of), 
etc. Expressions containing several subsets of parts each subset related via 
different operators, may be rather difficult to evaluate.
That's about all we will say for the moment about Exact n-d PC. It starts 
looking a bit complex, but its complexity and difficulty are childish compared 
with those of the Fuzzy, which is the one important for practice. 
Therefore, please shoot questions, so that we may clear all details before 
going to the real and exciting stuff of the Fuzzy n-d PC.