## Monday, September 14, 2015

### Differential Operators and Quantifiers

Differential Operators and Quantifiers

Consider the commutative operators on binary logic: A*B = B*A These are determined by three values:
T*T,   T*F  (which equals F*T),     and F*F.
Each of these can take two values; therefore there are 2*2*2 = 8 possible such operators:
T*T=T        T*F=T
F*T=T        F*F=T                 X*Y  =  T

T*T=T        T*F=T
F*T=T        F*F=F                 X*Y  =  X or Y

T*T=T        T*F=F
F*T=F        F*F=T                 X*Y  =  X iff Y

T*T=T        T*F=F
F*T=F        F*F=F                 X*Y  =  X and Y

T*T=F        T*F=T
F*T=T        F*F=T                 X*Y  =  Not(X and Y)

T*T=F        T*F=T
F*T=T        F*F=F                 X*Y  =  X xor Y

T*T=F        T*F=F
F*T=F        F*F=T                 X*Y  =  Not(X or Y)

T*T=F        T*F=F
F*T=F        F*F=F                 X*Y  =  F
Two of these are constant: T and F. Two are positive functions: And and Or. They have these rules:
x and y   =   y and x                ;                   x or y   =   y or x
x and x  =   x                           ;                  x or x  =   x
x and T  =   x                          ;                  x or F  =   x
x and F  =   F                          ;                   x or T  =   T
x and (y and z)  =   (x and y) and z
x or (y or z)  =   (x or y) or z
x or (y and z)  =   (x or y) and (x or z)
x and (y or z)  =   (x and y) or (x or z)

There are two negative functions: Nand and Nor.
x nand y  =  not (x and y)   =  not(x) or not(y)
x nor y  =  not (x or y)   =  not(x) and not(y)

There are two “differential” functions: Xor and Iff.
x iff y   =   y iff x           ;         x xor y   =   y xor x
x iff x  =   T                            ;         x xor x  =   F
x iff T  =   x                            ;         x xor F  =  x
x iff F  =   not(x)          ;         x xor T  =  not(x)
x iff (y iff z)  =   (x iff y) iff z  =   x xor (y xor z)  =   (x xor y) xor z
x iff y  =  not(x xor y) = x xor y xor T
x xor y  =  not(x iff y)  = x iff y iff F

Iff , Xor, And and Or can be mapped to arithmetic, modulo 2. Mapping F to 0 and T to 1 maps Xor to + and And to *; mapping F to 1 and T to 0 maps Iff to + and Or to *. Therefore these distribution laws:
x or (y iff z)  =   (x or y) iff (x or z)
x and (y xor z)  =   (x and y) xor (x or z)
And does not double-distribute over Iff, nor Or over Xor, but they do triple-distribute:
x or (y xor z xor w)  =   (x or y) xor (x or z) xor (x or w)
x and (y iff z)  =   (x and y) iff (x and z) iff (x and w)

Now consider quantifiers. These are extended versions of the above operators, operating on a predicate’s values in a universe of discourse. For instance, given a universe of discourse = {a,b}, and a predicate P(x) on {a,b}, then define:
A(x)(P(x))  = all x are P  =  P(a) and P(b)
S(x)(P(x))  = some x is P   =  P(a) or P(b)
No(x)(P(x))  = not one x is P  =  not (P(a) or P(b))
Na(x)(P(x))  = not all x are P  =  not(P(a) and P(b))
Nra(x)(P(x))  = none or all x are P  =  P(a) iff P(b)
Sbna(x)(P(x))  = some but not all x are P  =  P(a) xor P(b)
There are also two constant quantifiers T and F. Over a universe of discourse with two elements, the quantifiers are Or, And, Nor, Nand, Iff and Xor on P(a) and P(b).

Over a larger universe of discourse {a1, a2, a3…}, define:
A(x)(P(x))  =  P(a1) and P(a2) and P(a3) and …
S(x)(P(x))  =  P(a1) or P(a2) or P(a3) or …
No(x)(P(x))  =  not ( P(a1) or P(a2) or P(a3) or … )
Na(x)(P(x))  =  not ( P(a1) and P(a2) and P(a3) and … )
Nra(x)(P(x))  = No(x)(P(x)) or A(x)(P(x))
Sbna(x)(P(x))  = S(x)(P(x)) and Na(x)(P(x))

These equations apply:
A(P)   =  not S(not P)            ;         S(P)   =  not A(not P)
No(P)  =  A(not P)                 ;         Na(P)  =  S(not P)
Nra(P)  = Nra(not P)             ;         Sbna(P)  =  Sbna(not P)
Nra(P) = A(x,y)( P(x) iff P(y) )
Sbna(P) = S(x,y)( P(x) xor P(y))

Nra (“nunnerol”) is the constancy operator; true if P(x) is equally true for any two x; and Sbna (“sumbunol”) is the variability operator; true if unequally true for some two x. So an alternate notation for these “differential” quantifiers is
Sbna  =  V,  for Variability; “P is variable”.
Nra  =  C,  for Constancy; “P is constant”.
I also call these quantifiers “Wilsonian”, after the speculative-fiction writer Robert Anton Wilson, who coined “sumbunol” as a philosophical corrective to ideological overgeneralization.

Various deduction rules apply to the quantifiers. For any a and b:
A(P)                              implies       P(a)
P(a)                               implies       S(P)
No(P)                            implies       not P(a)
not P(a)                         implies       Na(P)
P(a) and Nrl(P)             implies       P(b)
P(a) and not P(b) implies       Sbna(P)
For any Boolean function F(p,q):
Nrl(P)  and  Nrl(Q)      implies       Nrl(F(P,Q))
Sbnl(F(P,Q))                 implies       Sbnl(P)  or Sbnl(Q)

If the universe of discourse has only one element {a}, then:
A(P)  =  S(P) = P(a)
Na(P) = No(P)  =  not P(a)
Sbna(P)  =  F
Nra(P)  =  T
And if the universe of discourse is empty, then:
A(P)  =  T
S(P) =   F
Na(P) = F
No(P)  =  T
Sbna(P)  =  F
Nra(P)  =  T
Assuming that the universe of discourse is not empty (i.e. S(x)(x=x); i.e. ‘something is itself’) then these equations follow:
Sbnl(P) and A(P)  =  A(P) and No(P)  =  No(P) and Sbnl(P)   =  F
Nrl(P) or Na(P)  =  Na(P) or S(P)  =  S(P) or Nrl(P)   =  T
Sbnl, A and No are pairwise disjoint; Nrl, Na and S are pairwise exhaustive. They join in pairs:
Sbnl(P)   =  not Nrl(P)  =  S(P) and Na(P)
A(P)  =  not Na(P)   =  Nrl(P) and S(P)
N(P)  =  not S(P)    =   Na(P) and Nrl(P)
Nrl(P)  =  No(P) or A(P)
Na(P)   =  Sbna(P) or No(P)
S(P)    =   A(P) or Sbna(P)
Therefore:
Variability = Existence and Exceptions
Universality = Constancy and Existence
Nonexistence = Exceptions and Constancy
Constancy  =  Nonexistence or Universality
Exceptions = Variability or Nonexistence
Existence  =  Universality or Variability

Here are Wilsonian versions of mathematical induction:
A(x)(P(x) iff P(x+1))             =       Nrl(x)(P(x))
Sbnl(x)(P(x))                          =       S(x)(P(x) xor P(x+1))