Would you like to make this site your homepage? It's fast and easy...
Yes, Please make this my home page!
PLAN OF CA PREREQUISITES
ca1 introduction to propositional calculus
ca2 introduction to predicate logic
caa 2D exact propositional calculus
cab ND exact propositional calculus
cac implication
BACK TO SITE PLAN
Site Plan
CAA.EXACT TWO-DIMENSIONAL PROPOSITIONAL CALCULUS
Propositional Calculus (PC) is an instance of Boole Algebra
(CA1.INTRODUCTION TO PROPOSITIONAL CALCULUS)
of operands and operators associated with binary variable
ranging over 0-1, which we call "certainty" for the sake of
consistency with Fuzzy Inference (CCA.COGNITIVE NETWORK).
"Propositional Calculus" is a misnomer confusing "operand"
with "proposition" due to Logic traditionally striving to be
rooted in Naive View as expressed by natural languages. The
same tendency confuses the 0-1 range of certainty with naive
noumenalistic terms "truth-falsity". Throughout its history,
Logic considered propositions as its only operands, was not
concerned with the certainty 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 Logic starts by inquiring how and to which
operands certainty may by premised before extending it to
other conclusion-operands. In this second task that we find
PC a useful prerequisite, considering it strictly as algebra
and disregarding its pretended linguistic implications.
For two-dimensional Calculus operators operate on 2 operands
and have a certainty variable being function of those of both
operands. As for operands, we shall say that "operator is
"true/false", implying by it the values "1/0" of its binary
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 most frequently used (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
"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.
Certainties 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 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. Thus,
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 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 and(pq) implies or(pq)
then p and q are equivalent. Result not quite obvious and
rather useful for instance in programming where we can
replace "imp(and(pq).or(pq))" with 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 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".
