# Primitive Logic

Let's think about logical rules AND and OR as if they are just procedures which "implements" the logical rules.

Let's denote Truth as 1 ans Falsehood as 0

So logical AND is in some sense same as multiplication by 0. Anything multiplied by 0 is zero, anything multiplied by 1 is just whatever it is, except zero.

If there is at least one False, then the whole thing is False, only True AND True is True

0 AND 0 is 0 0 AND 1 is 0 1 AND 0 is 0 1 AND 1 is 1

If there is at least one Truth then the whole thing is True, only False OR False is False

0 OR 0 is 0 0 OR 1 is 1 1 OR 0 is 1 1 OR 1 is 1

There are definitions of such rules, which, by magic, happen to be a procedure definitions:

Something AND True is something, whatever it is, BUT, Something AND False is indeed False (something times 1 is something, except for 0, anything times 0 is 0)

(&&) :: Bool -> Bool -> Bool -- let's ignore this clutter for a while. True && x = x False && _ = False

Something OR True is True, only False OR False is False

(||) :: Bool -> Bool -> Bool True || _ = True False || x = x

What is NOT True is False, what is NOT False is True.

not :: Bool -> Bool not True = False not False = True

Whole books could be written about the beauty of pattern matching, some day, perhaps.

There are recursive procedures defined for Lists in a beautiful foreign language

and :: [Bool] -> Bool and [] = True and (x:xs) = x && and xs

which must be posted on walls.

or :: [Bool] -> Bool or [] = False or (x:xs) = x || or xs

And there is another two pieces of an incredible beauty

and = foldr (&&) True

worth to be printed and framed

or = foldr (||) False

OK, let's leave foreign lands and return back to the world of Lisps.

**Note:**See TracWiki for help on using the wiki.