Vlorbik's Diner

son of owen's cooking show

testing testing

Posted by vlorbik on November 13, 2009

so part of the point here is to work
with the simplest things available
that’ll do the job.

so let U = {0,1}
be our domain.
and let p, q, and other
(lower-case roman)
letters to be named
in various contexts
be variables
denoting unspecified
values in this domain.

one common interpretation of
such variables as we’re introducing here
is that p and q (and so on)
denote statements
that are either true or false.
we’ll call this interpretation
“propositional calculus”–
which, being interpreted,
means what but
“the arithmetic of statements”.

certain operations on U will
first be examined. what gives here?

an “operation” is really just a certain
species of function. among
other things, this means that
“at bottom”… at the level of
definitions… it’s a certain set.

input-output pairs… the objects
functions (and other relations)
are “made of”, typically
represented as (x,y)-lookin
ordered pairs… will here (sometimes)
be denoted simply by juxtaposition:
00, 01, 10, and 11
rather than the considerably
more cumbersome
(0,0), (0,1), (1,0), and (1,1).

a remark on the license to create
notations at whim. urge everybody
to do this… and to try to understand
the nonce notations of others.
this’ll be a great deal of our art.
but at the same time of course
when you find something that
works… in notations this means
short-and-suggestive… *use* it!
(and urge others to do the same!)
that these’ll be medium-dependent
is as obvious as the screen
in front of your eyes.
handwriting matters most
though and don’t you forget it.
now.

the “operations” whereof i spoke
a moment ago, then. first of all.
the unary operators, aka
{\it functions of one variable}.

these are but few. hooray!
U only has two elements, baby.
how complicated can it be?
a unary operator will take a
“statement”… be it p or q
or be it 0 or 1 (or be it
“pascal wrote the *pensees*”
or be it
“quine wrote *quiddities*)…
and “return a value” of
true or false (1 or 0).
so here’s the lot.

00 10: the {\bf constant} function “at 0”
00 11: the “identity” operation
01 10: the “negation” operation
01 11: the constant function at 1

that’s it! (the exclamation denotes
feigned surprise and very real delight.)
just for laughs, i’ll write the whole thing up
in function notation. (if you’ve got any class
you’ll close the book now and try it on your
own before looking at mine… i’ve seldom
done this kind of thing myself you understand…)

there are, then, {\it four} Unary Booleans
(*i.e.*, functions on {0,1}). we’ll hereby call ’em
F ([the constant at] “false”… the nihilist function… just say no)
I (the identity… agreement with the argument)
N (the negation operation… *dis*agreement with the argument)
T (constant and true).

in detail… and again, here, the only point
in *me* doing this is to convince skeptics
that this is so simple that *they* should do it…

F(0) = 0 and F(1) = 0
I(0) = 0 and I(1) = 1
N(0) = 1 and N(1) = 0
T(0) = 1 and T(1) = 1

becomes the “ordinary *f*-notation” version
of the table i wrote out already as 00,10 etc.

exercise. there are sixteen booleans of two variables.
find ’em all and take ’em into your hearts. give ’em names.
learn other names than yours. settle only for the best.
if this is too much for you, try rewriting the (mere)
four Unary Booleans i wrote out already…
but in the standard “set of ordered pairs” fashion.
textbook closed of course. do *something*.
reading gets you nowhere in life take it from me.

here are a few examples. follow at your peril.
there’s probably a much better way to “see” this.
i’m claiming that because of its boneheaded simplicity…
like onto “machine code”… it makes a good
“bottom level representation” with which to
compare other representations likely to be
easier to read (and to work with in “higher-level”
discussions than this “foundational” work).

00.0
01.0
10.0
11.0
the constant at zero.

00.1
01.1
10.1
11.0
“nand” (aka “stroke”): true *unless* both arguments are true

00.0
01.0
10.0
11.1
the and operator.

to expand on this example.
in {\it infix} notation one
would rewrite the definition
of the AND operator (say) as
0 AND 0 = 0
0 AND 1 = 0
1 AND 0 = 1
1 AND 1 = 1
or even verbally as
“p AND q evaluates to TRUE
whenever both p and q
are themselves TRUE;
otherwise to FALSE”.

this too is futility and a striving after wind.

Advertisements

3 Responses to “testing testing”

  1. kibrolv said

    the sixteen boolean functions are displayed
    (and “named” via more-or-less common symbols)
    on p. 4 of this old handout
    of mine.

  2. vlorbik said

    not any more they aren’t. find my scribd page if you want.

  3. vlorbik said

    one would’ve liked to’ve thought to’ve tried some
    set-theory-for-beginners at the math circle.
    maybe some other time. (you gotta give ’em rope.)

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

 
%d bloggers like this: