## 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.

## 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.

## vlorbik said

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

## 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.)